A field guide to AI coding agents

"AI coding agent" covers two tools that share nothing but the noun. One finishes the line you're typing. The other takes a GitHub issue, writes the code, and opens the pull request while you're at lunch — and in 2026 it ships in products you can buy, not just demos. Same words, opposite jobs. Which one you're holding changes how you work.

This is a map of that gap: the rungs from autocomplete to autonomous, what changes as you climb, and how to hand off real work without getting burned. It's deliberately vendor-neutral — I name products only as examples. The roster turns over every quarter; the ladder doesn't.

The ladder

Most coding tools sit somewhere between "predicts what you'd type" and "does the task for you." Four rungs are worth naming.

Autocomplete. It finishes the line or block you're already writing. You drive; it guesses the next few tokens, fast enough to never break your flow. Real value, narrow: it speeds up keystrokes you were going to make anyway.

Chat. A panel you ask. It sees your file or selection, explains an error, drafts a function, refactors a snippet. The work comes back as text or a suggested edit; you decide what to apply and wire in.

Agentic CLIs and IDE agents. You give it a goal; it reads files, runs commands, edits across the repo, checks the result, and tries again. It works in a loop with your tools, and you review the diff instead of writing it. Claude Code, Aider, and the agent modes baked into modern editors live here. Names aside, the defining trait is that it acts.

Background agents. You hand off a whole task — an issue, a ticket — and it works on its own, usually remotely, then returns a pull request. Delegation stops being a turn in a chat and becomes an entire piece of work. A year ago this rung was a demo. In 2026 it's table stakes: GitHub's Copilot coding agent went GA — assign it an issue, it opens the PR — and Devin, Cursor's cloud agents, and Codex all do async PR work, with a Copilot CLI (June 2026) for the terminal.

The line that matters runs between the second rung and the third. Below it, the tool predicts or answers and you do the integrating. Above it, the tool acts and checks itself, and your job shifts to reviewing a diff it produced. Everything under the line makes typing faster; everything over it changes what you delegate.

Cross one line and the job changes: you stop integrating the output yourself and start reviewing a diff the tool produced.

The ladder keeps growing at the top. Above the agentic rung, an orchestration layer is forming — one operator running several scoped agents in parallel (Claude Code subagents, Codex's parallel delegation, Cursor's Agents Window, Google's Antigravity). It raises the premium on scoping rather than relaxing it: you can't eyeball ten diffs at once.

What "agentic" actually buys you

"Agentic" gets sprayed on every product page, so strip it to parts. Three things turn a chatbot into an agent.

Tools. It can do things, not just describe them — read files, run the test suite, grep the repo, execute code, hit an API. A model with tools observes reality instead of narrating a guess about it.

A loop. It acts, sees what happened, picks the next step, repeats. Run the test, read the failure, fix it, run it again — the cycle you'd otherwise drive by hand, which is where the leverage lives.

Verification. The loop is only worth as much as the agent's ability to check itself. One that can run your tests, types, or linter has a ground truth to move toward; one that can't is generating confident text and hoping. It's the single best predictor of whether an agent ships working code: can it tell, on its own, whether it succeeded?

So "agentic" isn't a measure of intelligence — it's whether the feedback loop is closed. It's why the same model feels brilliant in one repo and helpless in the next: give it fast, trustworthy checks and it converges; take them away and it produces confident nonsense at speed. I'll take a duller model with a closed loop over a sharper one running blind any day.

Where they shine, where they bite

The same trait that makes these tools strong makes them fail in predictable ways.

They shine on work that's scoped and checkable: make a failing test pass, port a module to a new API, add a field end to end, grind through patterned boilerplate. Anything with a fast automated check the agent can run itself sits in the strike zone.

They bite when the goal is fuzzy or the check is missing. Give an agent a vague task with no definition of done and it'll do something, confidently, and you'll burn more time reviewing it than the job was worth. Same when success is slow or manual to judge: subtle UX, performance with no benchmark. Worst is a big change on weak tests — the agent moves fast, and fast with no net is how a confident mess lands in main.

Which is why the core skill is scoping: shrink a task until its success is automatically checkable. A good prompt is mostly a good definition of done. Get that right and the model matters less than you'd think — the biggest lever on agent output is rarely a smarter model, usually a smaller task.

A workflow that compounds

I've watched human-in-the-loop go wrong both ways: rubber-stamping diffs you never really read, or babysitting every keystroke until the tool is slower than doing it yourself. The path between is a few habits.

Work in small, reviewable units. One task, one branch, a diff you can hold in your head — large autonomous changes are where trust quietly breaks.

Invest in the checks once. Every test, type-check, and lint you automate is leverage the agent reuses on every future task. The repo that's pleasant for an agent is pleasant for a human.

Review the diff, not the transcript. The code is the artifact — read it like a PR from a fast junior who never tires and never remembers yesterday.

Keep context tight. Point the tool at the right files instead of the whole repo; clear boundaries help an agent for the same reason they help you.

Each habit pays out on every task after. Better checks produce better output, which makes review faster, which lets you delegate more — the flywheel is real, but you have to build it before it spins. The same discipline runs through the open-source AI stack we'd actually build on: the boring parts, done well, hold the impressive parts up.

The cache

A few things worth keeping, the way we keep everything else here — examples, not endorsements.

• Pick one agentic CLI and learn it deeply. Claude Code, Aider, and the OpenAI Codex CLI are all reasonable first picks. Fluency in one beats a shallow tour of all three — you learn an agent's failure modes by living in it.
• Read the workflow writing, skip the leaderboard. The useful material on agents is about how to work — scoping, review, evals — not benchmark victory laps. Distrust the scores anyway: in early 2026 OpenAI's own eval team walked away from SWE-bench Verified — contamination and saturation — and moved to SWE-bench Pro. The case for measuring your own system is in write the eval before the prompt.
• Ask what ground truth it can reach. When a new tool shows up, skip "how smart is it" and ask what it can run and check for itself. That answer beats any demo.

Some names here are aging as you read them. Windsurf, the agentic IDE, was acquired by Cognition and folded into Devin Desktop this month; Google is retiring its consumer Gemini CLI into Antigravity. Give it a year and a third of this vocabulary will be wrong. The ladder won't move. Give a capable model real tools, a loop, and a way to check its own work, then hand it tasks whose success you can verify. Everything else is detail.

That's the field guide. Now go scope something small and hand it off.