11 — AI-Assisted Coding — All Roads Lead to the Agent

I used to draw the AI coding tools as a tidy line from "suggests a line" to "does the whole job." Copilot sat at the suggest end, Claude Code at the do-it-all end, and the other two somewhere between. Writing these notes again this year, I hit a problem: the line broke. All four tools — Copilot, Cursor, Claude Code, and Antigravity — now ship some version of an agent: a helper that doesn't just suggest text, but edits files, runs commands, and keeps going until the job is done [1]. The tidy spectrum collapsed.

What actually survived is two questions instead of one. Where does the agent live — in your editor, in your terminal, across the browser too, or off in the cloud? And how much do you hand over — do you want it to finish the line you're typing, steer it while it works, or give it the whole task and review the result? Every tool answers those two differently, and that's the real reason to pick one over another.

For the second question, keep the driving picture: cruise control holds a speed but you steer; a co-driver takes the wheel while you watch and correct; a chauffeur drives the whole trip and tells you when you've arrived. "How much you hand over" is just that ladder, and every one of these tools now offers several rungs.

Here's the honest picture — each tool as a span along that ladder, not a dot:

None of these tools is a single rung anymore. Copilot spans the whole ladder, from finishing your line to opening a pull request from the cloud. The real choice is which _rung_ you stand on, and which _workshop_ the helper works in.

What they all share

Strip the brands and the same machine is underneath all four: a large language model — the "guess the next word by weighing probabilities" engine from the previous note — pointed at your code and handed a toolbelt. An agent is just that engine plus the belt: it can read and write files, run commands in your terminal, and read the output, then decide the next step [1]. None of these tools replaces your build or your judgment; the deal is still "the model proposes, you decide." What changed is that all four now let the model _act_ on your files, not just propose.

GitHub Copilot — the full ladder

Copilot is the one that started the whole category, and it has since climbed every rung of it [2]. It began as the ghosted next line you accept with a tap — pure cruise control — and that's still there. But it now also has an agent mode inside your editor: give it a goal ("add a sign-in flow and write tests") and it edits files, runs the test suite, reads the failures, and loops until green, pausing for you to approve the risky steps. Above that sits a cloud agent: assign it an issue on GitHub and it works in the background, in its own workspace, and comes back with a pull request — reviewing its own changes and running security checks before it hands them over [3].

Copilot's edge is that GitHub integration. If your whole world already lives in GitHub issues and pull requests, the cloud agent slots straight into it. The trade-off is that it's spread thin: the inline suggestion, the editor agent, and the cloud agent are three different rungs, and you have to know which one you're reaching for.

Cursor — the editor built around an agent

Cursor is where the agent _is_ the product, not a bolt-on [4]. It's an editor (a rebuilt version of VS Code), and its centerpiece is an agent that searches your codebase, edits multiple files, runs terminal commands, and fixes its own errors — all in one loop, with the changes streaming into a diff you accept or reject as they land. It also has a plan mode that researches and writes a reviewable plan before touching anything, and background agents that run in the cloud and open a pull request when they're done [5].

The feel is "an agent with a steering wheel." You can watch every edit, approve every terminal command, and redirect mid-run — more hands-on than Copilot's fire-and-forget cloud agent, but just as able to run the whole task. If you want one place where you can be as hands-on or hands-off as the job needs, Cursor is that place.

Antigravity — the agent that reaches the browser and checks its work

Antigravity, Google's entry, isn't the autocomplete it can look like at a glance [6]. It's an agentic IDE: a full editor where the agent can operate not just across your editor and terminal, but _drive a browser too_ — loading your running app, clicking through it, and using what it sees to keep working. Its other signature is verification: it leans on running the thing and checking the result, rather than trusting that the edit was right.

On top of that, Google has split the agent out of the editor entirely. A separate app lets you run _several_ agents in parallel across projects and watch them from one screen, and there's a terminal version and a way to build your own agents [6][7]. The trade-off: it's the youngest and most Google-shaped of the four, so it pulls you toward Google's way of working. The win is the browser plus verification — the closest thing to "the agent checks its own homework before you have to."

Claude Code — the terminal chauffeur

Claude Code sits at the far end of the hand-over ladder and lives in the most stripped-down place: your terminal, no editor at all [8]. You describe a task in plain language, and it plans, edits files across the project, runs commands (tests, build, git), reads the output, and keeps iterating until it's done or hits something it should ask you about. You review the result rather than steering each step.

That's the whole pitch — a chauffeur you talk to over the terminal, no cockpit. The trade-off is the mirror image of Cursor: no diff streaming by as it works, no editor to watch it in; you get a summary of what it did and you check the repo after. It's the right tool when the task is "make this work, across whatever files it takes, and tell me when you're done" — a fresh experiment, a change that touches the whole project, a bug whose location you don't know. It's the wrong tool when you want to watch every keystroke.

How I use this

The collapse of the spectrum is actually a relief: I stopped asking "which tool is more advanced" (they've all converged) and started asking the two questions that still matter. Where does the agent need to live? If the work is all in my editor and I want to watch it, Cursor or Copilot. If I want it to actually run and poke at the live app, Antigravity. If I just want to type a goal into a terminal and review later, Claude Code. How much do I hand over? The same task can sit at different rungs: finish the line (inline), steer it while it works (editor agent), or hand it over and review the pull request (background/cloud). Naming those two — where, and how much — is what turned a confusing menu into a choice I can make in five seconds.

References

[1] roadmap.sh, "AI-Assisted Coding," Frontend Roadmap, 2026. [Online]. Available: https://roadmap.sh/frontend/ai-assisted-coding

[2] GitHub, "Quickstart for GitHub Copilot," GitHub Docs, 2026. [Online]. Available: https://docs.github.com/en/copilot/quickstart

[3] GitHub Blog, "The difference between coding agent and agent mode in GitHub Copilot," 2025. [Online]. Available: https://github.blog/developer-skills/github/less-todo-more-done-the-difference-between-coding-agent-and-agent-mode-in-github-copilot/

[4] Cursor, "Agent — Cursor Help," cursor.com. [Online]. Available: https://cursor.com/help/ai-features/agent

[5] Cursor, "Cursor Docs," cursor.com. [Online]. Available: https://cursor.com/docs

[6] Google, "Antigravity IDE — Overview," antigravity.google. [Online]. Available: https://www.antigravity.google/docs/ide/overview/

[7] Google, "Google Antigravity," 2026. [Online]. Available: https://antigravity.google/

[8] Anthropic, "Claude Code Overview," code.claude.com, 2026. [Online]. Available: https://code.claude.com/docs/en/overview