Microwave Update 2026 · Living resource

From Soldering Irons to Syntax

How hams build real station tools with generative AI, and how to tell good output from slop. Principles, a prompt library, a gallery of working projects and a step-by-step setup guide.

New here?Start with the three rules of the grounded builder. Want to build tonight?Copy a prompt, add your rules or datasheet, go. Already building?Check your repo against what good looks like.

The Grounded Builder

Amateur Radio has always been a maker's hobby. We didn't stop building when tubes gave way to transistors, or through-hole to surface mount. Software has been the wall for many of us: hardware follows physics, but software can feel like a labyrinth of syntax, toolchains and frameworks.

Generative AI is a new building material, like copper wire or silicon. It handles the syntax. You still decide what to build, and you still decide whether it works.

Ask a generic chatbot a generic question and you get AI slop: bloated, buggy, plausible-looking code. The fix isn't a better chatbot. It's three habits.

1. Curate before you code

Never let the model guess the rules or the formulas. Hand it the primary source:

Left to search the web on its own, a model can land on out-of-date or non-authoritative sources. Curation is the filter.

2. Isolate the context

One project, one folder, one conversation. Give it only the sources that matter to this project. Mixing your EME siting calculator and your remote keyer in one thread blurs both.

3. Be the control operator

The AI writes syntax. Logic, error boundaries and compliance stay yours. You are the architect; the AI is the high-speed technician. In practice that means:

Two real examples from 10ghz-log-analyzer: a blank spreadsheet row that was forward-filled into a phantom duplicate QSO (fixed in v1.5.1), and band multipliers above 122 GHz that didn't match section 5.2 of the rules (fixed in v1.6.1). Both looked fine at a glance. Both were caught by checking against the rules and real logs.

More real examples, and what each one teaches, are in the field notes.

The workbench (October 2026)

Like choosing a transceiver for a band, pick the tool for the job. This is my experience on my own projects; test yours against your own source material.

Tool What I use it for My verdict
Claude (desktop app, web, mobile) Multi-file projects in local folders, code, tests, documentation, slide decks, websites Primary. Covers nearly everything I do
Gemini Notebook Source-grounded research, image generation, podcast-style audio overviews Very much worth a look, especially for learning a topic and for media
Kiro Spec-first IDE (a VS Code fork) for people who live in an editor Rarely, now. Claude covers what I used it for
ChatGPT Complex technical work Hard no. Consistently poor results for me, most recently a schematic that stayed wrong through multiple rounds of correction

What changed since the paper (August 2026)

Learning companions

Prompting: the anatomy and the staircase

Anthropic's own advice is to treat the AI like a brilliant new colleague who has never seen your station. Write your prompt so that a sharp club member with no background could follow it. If they'd be confused, the AI will be too.

You don't need special words, role-play or formatting tricks. Plain sentences, the real files and the reason you want the result do most of the work.

Anatomy of a prompt that works

Part What it says Example
Goal and why What you want, and what it's for "I want maps of the grid squares I worked in the 10 GHz contest, so I can share them with the other rovers."
Input The real material, attached "My Cabrillo 3.0 log from the 2025 10 GHz and Up contest, attached."
Output Exactly what you want back, and where it will run "One high-resolution PNG per band. Darker squares for more contacts, labels only on grids I worked, map sized to fit the log. One command, on my Mac or my Windows PC."
When unsure Permission to ask, and to admit it doesn't know "Ask me questions before you start. If the log is unclear, say so instead of guessing."

Why each part matters:

Not a developer? Leave the libraries out. Describe the result you want and where it will run, and let the model choose the tools. If you are a developer, name them.

What you can skip

Older prompting guides suggested habits that today's models don't need:

Inputs and outputs from real projects

The same pattern, from the projects in the gallery:

Project Input: what I attached Output: what I asked for
10ghz-log-analyzer My Cabrillo or CSV log, and the ARRL rules PDF A submittable Cabrillo file with claimed score, plus polar plots by direction and band
optical-receive-chain Photodiode and op-amp datasheets, and "flat from 500 Hz to 15 kHz" A small calculator that prints stability, bandwidth and noise, not just a part value
portable-10ghz-eme My station: 76 cm dish, 25 W, 1 dB noise figure, fixed horizontal polarization The link budget first, then a step-by-step build doc for each pointing option
remkey How my station is wired: IC-7610, tower-top transverter, AnyDesk A build plan covering what happens if the link drops mid-transmit, before any code

The input is the real thing. The output is something you can check.

Climb the staircase: build in steps you can check

Build in steps, each on working results from the last, so you're never debugging five new problems at once. It's the same as bringing up a microwave chain: LO, then mixer, then PA, then sequencing.

  1. Spec and architecture. Write down the requirements and the approach before any code.
  2. File in, file out. "Read this Cabrillo log and print the QSO count per band."
  3. Core logic and math. Parsing, distance and bearing, scoring.
  4. Visuals and interface. Maps, plots, a web page.
  5. Polish, test, document. Edge cases, tests, README, changelog.

Today's models can take on much bigger jobs in one go than they could a year ago. The steps aren't there because the AI can't cope; they're there for you. Each one ends with something you can run and check before you build on it.

The one habit to start with

Ask me clarifying questions before you write any code.

Its questions surface design decisions you hadn't made yet.

Ready-to-adapt prompts are in the prompt library.

Prompt library

Templates modeled on how the projects in the gallery were built. Copy one, replace the bracketed parts, attach your real files, and start a fresh conversation per project. Each one follows the anatomy: the goal and why, the input, the output, and what to do when unsure. Every one assumes you've said: "Ask me clarifying questions before you write any code."


1. Score a contest from the official rules

Pattern behind 10ghz-log-analyzer.

I'm a ham radio contester, not a developer. I want a tool that scores my
[CONTEST NAME] log so I can check my claimed score before I submit it.
Please write clear, well-commented code that I can follow.

I've attached the official rules and my real log in [Cabrillo 3.0 / CSV
with columns ...]. Score the log exactly as the attached rules say. Use only
those rules, because versions found online may be out of date. If the rules
are ambiguous, stop and ask me.

Start with step 1 only: read the log and print the number of QSOs per band.
Then we'll add scoring, then reports, one step at a time.

When we get to scoring, add a test that pins every multiplier and point
value to the rules section it came from.

2. Map grids worked from a log

Pattern behind grid-mapper.

I want a map of the Maidenhead grid squares in a contest log, one image
per band, with darker squares for more contacts and labels only on grids
I worked. Input is a Cabrillo log (sample attached). It should run with one
command on Mac or Windows. I don't know which mapping libraries to use;
pick sensible ones and tell me why. Size the map automatically to the area
the log covers.

3. Revise someone else's firmware, with credit

Pattern behind ve2ug-optical-beacon-project.

Attached is [AUTHOR, CALL]'s original sketch and documentation for
[PROJECT]. Review the firmware for timing and robustness problems and
propose fixes, but don't change the core behavior without asking.

Then set it up as a GitHub repo:
- README with a version table and a test-status table (what's verified,
  what isn't)
- CHANGELOG with "Added", "Changed", "Unchanged" (what's still the original
  author's) and the reason for each change
- credit the original author everywhere the design is described
- no real credentials in the code; placeholders with a warning
Convert the original PDF docs to Markdown under docs/.

4. Turn a design decision into a calculator

Pattern behind tools/tia_calc.py in optical-receive-chain.

I'm building a photodiode transimpedance amplifier: [PHOTODIODE] at
[BIAS], [OP-AMP], target flat response [F1] to [F2]. Datasheets attached.

Don't just tell me Rf and Cf. Write a small Python script, standard library
only, that calculates stability margin, bandwidth, noise and DC headroom,
with presets for [OP-AMP LIST], and prints a table. Say in the output which
numbers are ballpark datasheet values I should measure on my own build.

Swap in your own problem: path loss and link budget between two grids, rain fade at 24 GHz, dish wind load, feed offset.

5. Specify a station system before building it

Pattern behind remkey.

I want to [GOAL, e.g. send CW with my own paddle to my shack remotely].
My station: [RIG, interfaces, what runs on the shack PC, how I reach it
remotely, what I won't change]. Constraints: [safety, latency, budget,
parts on hand].

Before any code, write docs/build-plan.md: the architecture, the failure
modes and what the system does in each (especially link loss while
transmitting), a parts list, and a phased build and test plan. Ask me
about anything you'd otherwise assume.

When we write code: tests that run without hardware, a simulation of the
firmware if possible, and CI on every push.

6. Put a web front end on a working command-line tool

Pattern behind 10ghz-web-logger-analyzer.

My command-line tools [REPO LINKS] work and are tested. Build a web front
end that runs them unmodified (vendor them in with a sync script; never
hand-edit the copies). Users upload a log and download results.

Add a test proving the web app's outputs match the CLI's for the same log.
Deploy target: [my own computer only / AWS serverless / GitHub Pages
static site]. Give me a local mode that runs without the cloud.

7. Your house rules (set once)

Put this in a project's instructions, or ask Claude to remember it.

House rules for all my GitHub projects:
- Commit as [NAME] <[ID]+[USER]@users.noreply.github.com>. Never use my
  personal email.
- Versioning: [date-based YYYY.MM.DD / semantic].
- Every change gets a CHANGELOG entry with the reason.
- README always has: what it is, how to run it, current version, and what
  has and hasn't been tested.
- No secrets in the repo. Placeholders plus .gitignore.
- Credit upstream authors. Link restricted datasheets; don't copy them.

8. Report a bug so it gets fixed properly

I ran [COMMAND] on [INPUT, attached] and got this:

[PASTE THE FULL ERROR OR WRONG OUTPUT]

Expected: [WHAT THE RULES / DATASHEET SAY IT SHOULD BE].
Find the root cause before changing anything. Fix it in place, add a test
that would have caught it, and add a CHANGELOG entry that says who is
affected.

9. Analyze a design, and keep the analysis honest

Pattern behind offset-microwave-dish-comparisons.

I want to know how much gain [DISHES / ANTENNAS / FEEDS] really give on
[BANDS, exact frequencies, e.g. 10.368 and 24.192 GHz], and what eats into
it. References attached: [papers, datasheets, measured data].

Write a small Python calculator plus a script that regenerates every table
and chart in the README from it. Add tests that pin results to values I can
check by hand or from the references, including a test for any common
formula mistake you know of. Add CI that runs the tests and fails if the
README tables are out of date.

List every assumption in an "Assumptions and limits" section. Where the
references disagree, say so instead of picking one silently.

10. Run the numbers before you choose the build

Pattern behind portable-10ghz-eme.

```text Goal: [e.g. 10 GHz EME contacts with my portable station]. Station: [dish, power, noise figure, polarization, IF radio, mount, parts on hand]. Target stations: [what the other end typically has].

Before suggesting any hardware, do the link budget and tell me how much margin there is and which factors matter most. Then answer my open question, [e.g. is hand pointing good enough or do I need a rotator?], from those numbers.

If more than one build makes sense, write each as its own step-by-step doc with a parts list and build time, plus a comparison table in the README and your recommendation.

Project gallery

Real, public, AI-assisted ham radio projects by K2UA. Each one shows a technique worth copying.

Microwave and contesting

Project What it does Technique to copy
10ghz-log-analyzer Scores ARRL 10 GHz and Up logs, writes Cabrillo, plots points by compass direction and band Ground in the rules. Scoring tied to the rules document; every fix documented with who it affects (see field notes)
10ghz-web-logger-analyzer · live site Web edition: upload a log, get Cabrillo, reports, polar plots and maps in one .zip Engine before dashboard. Runs the CLI tools unmodified, with a web-vs-CLI parity test, CI on every push, and a deploy script that refuses unsafe changes
grid-mapper Maidenhead grid density and path maps from a Cabrillo log, per band, with an optional street-map underlay Describe the output, not the libraries. One command, automatic scaling
offset-microwave-dish-comparisons How much gain 0.6–0.9 m offset and prime-focus dishes really give on 10.368 and 24.192 GHz: efficiency, illumination, blockage, surface error, and the W1GHZ dual-band feed Pin the math with tests, regenerate the docs. A test guards the classic "efficiency squared" gain-formula mistake, and CI fails if the README tables drift from the code
portable-10ghz-eme 10 GHz moonbounce with a 76 cm portable dish and Q65-60D: the link budget, then two pointing builds (manual sighting, or Mini-RAS auto-tracking) Link budget first, then decide the build. The numbers showed a 2.7° beam makes hand pointing realistic, so the rotator became an option rather than a requirement
eme-calculator-project EME dish siting: moon windows, tree loss by band, wind load Start small, iterate. Experimental, and labeled that way

Optical and hardware

Project What it does Technique to copy
ve2ug-optical-beacon-project VE2UG's ESP8266 Q65/CW optical beacon, revised with an NTP sync guard, Wi-Fi timeout and diagnostics Respect the source. Credit, an "Unchanged" list, honest test status
optical-receive-chain 940 nm receiver: lens, PD49PI, TIA, TDA2050, with SVG schematics and test tools Make it show its math. A re-runnable TIA calculator instead of a one-off answer
remkey Remote paddle CW for an IC-7610 driving a tower-top 10 GHz transverter, plus LoRa tower telemetry from two nodes (tower top, and a supply box at the tower base). Remote CW runs end to end on the real station over Tailscale; a web dashboard shows the telemetry in the shack, and a read-only cloud copy lets people (with a password) and Claude check the tower from anywhere Tests before the tower. CI on three OSes and firmware simulation first; then real-station findings (VPN coexistence, a USB unplug mid-transmit) written straight back into the docs
adalm-pluto-resources PlutoSDR firmware comparison and a GPSDO reference-clock mod Documentation is a deliverable. Sourced, geography-aware guidance

Logs, data and results

Project What it does Technique to copy
nyqp-dashboard · live site Interactive New York QSO Party results Zero-build static site. HTML, CSS and Chart.js on free GitHub Pages hosting
nyqp-cabrillo-fixer Turns irregular submitted logs into rules-compliant Cabrillo 3.0 Normalize messy data before anything downstream sees it
ham-mcp MCP server that lets an AI query ADIF and Cabrillo logs from Google Drive or S3 Connect your data. (No authentication yet; see MCP safety)
arrl-lotw-resources Python tools for downloading and working with your LoTW QSO history Read the API docs first, then automate

In progress (not yet public)

Field notes: bugs caught, and how

Real defects from the projects in the gallery. Every one looked fine at a glance. None was caught by reading code; each was caught by checking against a primary source, a real log, real hardware, or a test. This is what "be the control operator" means in practice.

Caught against the rules and real logs

Project What was wrong How it was caught The fix
10ghz-log-analyzer v1.5.1 A blank spreadsheet row was forward-filled into a phantom duplicate QSO Comparing the output with the actual log Forward-fill only date, band, grid and time; never invent a call sign
10ghz-log-analyzer v1.6.1 Bands above 122 GHz scored 6x and 10x; the rules give every band from 122 GHz up 5x Checking the score against rules section 5.2 Multipliers corrected, and a test now pins the table to the rules
10ghz-log-analyzer v1.6.2 A "142 GHz" band with Cabrillo code 142G. There is no such band: the allocation is 134 GHz, code 134G Reviewing a slide about the previous bug, two nights before a talk Renamed everywhere; old logs that say 142 still load and score correctly
10ghz-log-analyzer v1.6.3 Every Cabrillo file said it was made by v1.5.3, whatever the release Reading a generated log's header One version number, used everywhere

The pattern: a band table, a multiplier, a version string. Small, confident and wrong. You are the domain expert, and this is exactly where you'll notice.

Caught by tests and CI

Caught on real hardware

remkey's software passed CI on three operating systems before it touched the radio. Running it on the real station still turned up things no test could:

Each finding went straight back into the README and build plan, so the next builder doesn't hit it.

The takeaways

  1. Check output against the source, not against your sense that it looks right.
  2. When you find a bug, add a test that would have caught it, and a changelog line that says who's affected.
  3. Let CI check your docs too, when they're generated from code.
  4. Write down what hardware testing teaches you, in the repo, the same day.

What good looks like: the repo checklist

Every project in the gallery aims for this. None of it is hard, and the AI will do nearly all of it if you ask once and make it a house rule.

Protect your email before your first commit

Commits are public and permanent. Find your noreply address in GitHub Settings → Emails (it looks like 1234567+yourname@users.noreply.github.com), then:

git config --global user.email "1234567+yourname@users.noreply.github.com"

In the same Emails settings you can turn on "Block command line pushes that expose my email." Then tell your AI tool to use the noreply address for every commit.

MCP: connecting AI to your data, safely

The Model Context Protocol (MCP) is a standard plug between an AI assistant and your data or tools, much as a TNC connected a radio to a computer for packet. With an MCP server connected, you can ask things like:

That last pattern is grounding again, through a different pipe: connect an authoritative documentation server, then tell the model to use only it.

My ham-mcp project is a simple example: it lets an AI query ADIF and Cabrillo logs, and PDFs, stored in Google Drive or Amazon S3.

The catch: a security minefield

As of May 2026 (figures cited in the Proceedings paper):

Figure What it means
22,775 MCP servers listed in the Glama directory. Most are weekend projects
36.7% of public MCP servers carry server-side request forgery (SSRF) vulnerabilities
41% have no authentication at all, including my own ham-mcp
8.5% use OAuth

These numbers will have moved; the lesson hasn't.

Where to start

  1. Vendor-maintained servers first: the Filesystem server, GitHub's official MCP server, and cloud providers' documentation servers.
  2. Add community servers only once you can read their code and know what they can reach.
  3. Give each server the least access it needs: one folder, not your home directory; read-only where possible.
  4. Not every AI environment allows MCP connections. Check your tool's connector settings.

Getting started with GitHub

GitHub is a free place on the web where your project files live, with every version saved, and where you can share them when you're ready.

The easy way: ask Claude

You don't need to learn GitHub's commands to use it. After a one-time setup, Claude can manage it for you.

  1. Make a free GitHub account at github.com, in your web browser.
  2. Connect it once, with guidance. You can use the GitHub website or the command line, whichever you're comfortable with. Claude can walk you through either, one step at a time.
  3. Start one project with Claude. Attach the rules or the datasheet, and climb the staircase.
  4. Let Claude manage GitHub. Saving versions, keeping your email address private, and sharing the project when you're ready. Just ask.

Don't know where to start? Ask Claude:

Walk me through getting started with GitHub, step by step.

Two good habits to ask for on day one: start projects private and make them public only when you mean to share, and use your GitHub noreply email address so your personal one never appears in public.

The manual way: every step yourself

If you'd rather do it yourself, or want to see what Claude is doing for you, here is the whole process: installing Git and the GitHub command-line tool, building in a local folder with your AI companion, and publishing. Open the section for your computer. Each one is complete on its own.

Windows (PowerShell)

Step 1: Install the tools and sign in

  1. Create a free account at github.com.
  2. Open PowerShell: click Start, type PowerShell, and open Windows PowerShell (or Terminal, which opens PowerShell). Use it rather than the old Command Prompt.
  3. Install Git and the official GitHub CLI with Windows' built-in installer, winget:

    winget install --id Git.Git -e --source winget
    winget install --id GitHub.cli -e --source winget
  4. Close PowerShell and open it again so it finds the new commands. Then sign in:

    gh auth login

    Follow the prompts to sign in through your browser. No passwords typed into PowerShell.

Step 2: Protect your email address

Before your first commit, set Git to use your GitHub noreply address. Find it in GitHub Settings → Emails:

git config --global user.name "Your Name, CALL"
git config --global user.email "1234567+yourname@users.noreply.github.com"

While you're there, turn on "Block command line pushes that expose my email."

Step 3: Start a project folder

mkdir $HOME\my-ham-radio-project
cd $HOME\my-ham-radio-project
git init -b main
notepad .gitignore

Notepad opens a new .gitignore file, which tells Git to skip local clutter. Paste this in, save, and close Notepad:

.venv/
venv/
__pycache__/
*.pyc
Thumbs.db
.env

Step 4: Build with your AI, in that folder

  1. Open the Claude desktop app and point it at your my-ham-radio-project folder (in your user folder, for example C:\Users\yourname\my-ham-radio-project).
  2. Attach your source material: the rules, a datasheet, a sample log.
  3. Start up the staircase with step 1. For example:

    Ask me clarifying questions before you write any code. I want a Python script named log_parser.py in this folder that reads my Cabrillo log contest.log and prints the number of contacts per band, so I can check my totals before I submit.

  4. When something breaks, give it the evidence:

    I ran the script and got this error: [paste]. Find the root cause and fix log_parser.py in place.

  5. Ask for a README and a CHANGELOG as you go, not at the end.

Step 5: Publish to GitHub

Start private; make it public when you're ready to share. In PowerShell, in your project folder:

gh repo create my-ham-radio-project --private --source=. --remote=origin
git add .
git commit -m "First working log parser"
git push -u origin main

After that, each update is:

git add .
git commit -m "Describe what changed and why"
git push

To share later: repository Settings → General → Danger Zone → Change visibility. To share privately, add collaborators under Settings → Collaborators.

Step 6 (optional): Free web hosting with GitHub Pages

If you built a web page or dashboard (like nyqp-dashboard):

  1. Put the web files (index.html and friends) in a docs folder in your project.
  2. Add an empty .nojekyll file there so GitHub serves the files as they are, and publish:

    New-Item docs\.nojekyll -ItemType File
    git add docs
    git commit -m "Add web page"
    git push
  3. On GitHub: Settings → Pages → Build and deployment, source Deploy from a branch, branch main, folder /docs. Save.

  4. A minute or so later it's live at https://your-username.github.io/my-ham-radio-project/.

On a free GitHub account, Pages needs a public repository, and the published site is public.

Mac (Terminal)

Step 1: Install the tools and sign in

  1. Create a free account at github.com.
  2. Open Terminal: press Cmd+Space, type Terminal, and press Return.
  3. Install Homebrew if you don't have it yet, by following the one-line instructions at brew.sh. Then install Git and the official GitHub CLI:

    brew install git gh
  4. Sign in:

    gh auth login

    Follow the prompts to sign in through your browser. No passwords typed into Terminal.

Step 2: Protect your email address

Before your first commit, set Git to use your GitHub noreply address. Find it in GitHub Settings → Emails:

git config --global user.name "Your Name, CALL"
git config --global user.email "1234567+yourname@users.noreply.github.com"

While you're there, turn on "Block command line pushes that expose my email."

Step 3: Start a project folder

mkdir ~/my-ham-radio-project
cd ~/my-ham-radio-project
git init -b main
touch .gitignore
open -e .gitignore

TextEdit opens a new .gitignore file, which tells Git to skip local clutter. Paste this in, save, and close TextEdit:

.venv/
venv/
__pycache__/
*.pyc
.DS_Store
.env

Step 4: Build with your AI, in that folder

  1. Open the Claude desktop app and point it at your my-ham-radio-project folder (in your home folder).
  2. Attach your source material: the rules, a datasheet, a sample log.
  3. Start up the staircase with step 1. For example:

    Ask me clarifying questions before you write any code. I want a Python script named log_parser.py in this folder that reads my Cabrillo log contest.log and prints the number of contacts per band, so I can check my totals before I submit.

  4. When something breaks, give it the evidence:

    I ran the script and got this error: [paste]. Find the root cause and fix log_parser.py in place.

  5. Ask for a README and a CHANGELOG as you go, not at the end.

Step 5: Publish to GitHub

Start private; make it public when you're ready to share. In Terminal, in your project folder:

gh repo create my-ham-radio-project --private --source=. --remote=origin
git add .
git commit -m "First working log parser"
git push -u origin main

After that, each update is:

git add .
git commit -m "Describe what changed and why"
git push

To share later: repository Settings → General → Danger Zone → Change visibility. To share privately, add collaborators under Settings → Collaborators.

Step 6 (optional): Free web hosting with GitHub Pages

If you built a web page or dashboard (like nyqp-dashboard):

  1. Put the web files (index.html and friends) in a docs folder in your project.
  2. Add an empty .nojekyll file there so GitHub serves the files as they are, and publish:

    touch docs/.nojekyll
    git add docs
    git commit -m "Add web page"
    git push
  3. On GitHub: Settings → Pages → Build and deployment, source Deploy from a branch, branch main, folder /docs. Save.

  4. A minute or so later it's live at https://your-username.github.io/my-ham-radio-project/.

On a free GitHub account, Pages needs a public repository, and the published site is public.

Connecting Claude to GitHub

You can also connect Claude to your GitHub account so it can read and update your repositories directly. Ask Claude: "How do I connect you to my GitHub account?" and follow the current instructions for your plan. See also GitHub's getting started docs.

Common questions

"Doesn't AI just produce slop? It can't write real radio software." Ask a chatbot with no context and you'll often get exactly that. Give it the rules document, the datasheet and a sample log, build in small steps, and check the output against those sources, and you get tools you can trust on contest weekend. The difference is curation and verification.

"Isn't this cheating? Real hams write their own code." Hams didn't stop building when we moved from tubes to microchips. AI handles the syntax and typing. The system design, the testing and the judgment about whether it's right are still yours.

"Do I need to pay?" The free tiers are capable enough for a first project. Paid plans (roughly $20 a month at the entry level) make sense once you're running bigger multi-file projects or hitting usage limits. Check current pricing for your tool.

"What about my private logs?" Work in a local folder and give the AI only the files the task needs. Be aware that whatever the AI reads is sent to the model to be processed, so check your account's data and privacy settings, and keep anything sensitive out of the folder. MCP servers you run yourself let you control exactly what the AI can reach; see MCP safety.

"I'm not a programmer. Can I really do this?" Yes. I'm not one either. Describe what you want the output to look like and where it should run, and let the model choose the libraries. Your job is knowing what "right" looks like.

"Which tool should I start with?" See the workbench. I use Claude for nearly everything now.