Choosing a coding agent is no longer choosing a model
For two years, choosing what to code with meant choosing a model. That reasoning stopped working in 2026. The four agents almost everyone uses —Claude Code, Codex, Copilot and Cursor— run the same frontier models, with context windows of the same order and prices that at the top of the range are identical: a million input tokens costs 10 dollars on GPT-6 Astra and on Claude Fable 5.1 alike, and 50 for output.
There is a more convincing proof than any pricing table: since February 2026, on GitHub you can assign the same issue to Claude, Codex and Copilot at the same time and compare the three pull requests they open. If the model were the deciding factor, that feature would make no sense.
What remains as the real difference is the harness: the program around the model that decides what it reads, what it can run, where it runs, and how much it asks you before doing anything. That is what you are choosing now, and it is a decision about how you want to work, not about which model is smarter.
An example of what that means in practice. You give the same instruction to two agents —“fix the bug making this test fail”— with the same model behind both. One shows you which files it is going to read, asks permission before touching them, runs the test in front of you and stops if something does not add up: you are done in ten minutes having seen every step. The other takes the task away to a machine in the cloud, tries three approaches in parallel and twenty minutes later leaves you a draft pull request: you saw nothing, and now you have to review. The model wrote similar code both times. What changed —how much you found out, when, and what you could interrupt— was decided by the harness.
What converged
It is worth being clear about what stopped being a selling point, because that is half the decision you can discard:
- The models. All four let you pick between models from Anthropic, OpenAI and Google, and when a new one ships it appears in all of them within weeks.
- Context. A million tokens stopped being news; the models all four run have it.
- MCP. The protocol for connecting external tools was adopted by all of them. An MCP server you write today works in all four.
AGENTS.md. The project instructions file stopped being proprietary. What you write for one is read by the others.
Claude Code: to supervise and customize
Claude Code lives in the terminal and is built for you to direct it closely and shape it to your project. It exposes the most customization surface, in four layers worth keeping straight: skills (knowledge it loads only when relevant), hooks (shell commands fired at lifecycle events, which being code do not depend on the agent remembering), subagents (fresh instances with their own context that return only a summary) and agent teams, where an orchestrator splits work among several that message each other.
That same flexibility is its cost: it has to be configured to pay off, and running several agents in parallel consumes your quota in parallel. Ten agents spend ten times faster, which is not obvious until the bill arrives.
Codex: to delegate
Codex makes the opposite bet. Instead of fine control over an agent you watch work, it gives you coarser boundaries and the expectation that you hand over the whole task: it runs in isolated cloud sandboxes, launches several agents in parallel, and comes back when it is done. Since 4 September 2026 its default model is GPT-6 Astra, built precisely for long multi-step tasks.
The flip side is the one delegation always has: if it started from the wrong premise, you find out at the end. It works much better for bounded, verifiable work —a mechanical migration, a bug with a failing test— than for something where the definition of the problem gets clearer as you solve it.
Copilot: the one you probably already have
Copilot is the least chosen and the most used, because in many companies it comes issued. Its agent works asynchronously from GitHub itself: it spins up a virtual machine in Actions, makes the changes and opens a draft pull request. It is not in your editor watching you code; it is in the review flow, which is where your team already works.
If it is what you have, what pays off is using it where it is strongest —tasks that end in a reviewable PR— and not fighting it to be an interactive pair, which is exactly what it is not. Put differently: the tasks you would hand someone as a ticket come out well; the ones you would solve sitting next to someone do not.
This is worth spelling out because it is the most common case and the worst
served: having Copilot imposed does not stop you from using another one for
what Copilot does not do. All four coexist in the same repository with no
special setup, precisely because they read the same AGENTS.md.
Cursor: the IDE is the product
Cursor is the only one of the four where the agent is not an addition but the reason the editor exists. Its 2026 bet is autonomy control: a slider to dial how much freedom you give it per task, instead of a single mode. Its background agents run on git worktrees or remote machines, which is the tidy way to have several working without stepping on each other.
The entry price is changing editors. If you already live in VS Code or a JetBrains IDE, that weighs more than any feature difference.
How to choose by the work
The useful question is not which is best, but how much you are going to watch:
- Work you understand well and want to direct step by step —architecture, large refactors, anything where judgement matters more than speed—: an agent you supervise closely, customized to your project. Claude Code is built for that.
- Bounded, repetitive, verifiable work —migrating fifty files, fixing a bug with a failing test—: parallel delegation. Codex is built for that.
- Teams where everything goes through the pull request: the agent that already lives there saves you integrating anything. Copilot is built for that.
- If the editor is where you spend the day and you want the agent there: Cursor, at the cost of moving.
And one rule that holds for all four: an agent does not make up for a repository that cannot verify itself. Without a command that runs the tests, none of the four can know whether what it wrote works — we covered that in detail here.
Today’s snapshot, which will age
This section is the one to read with a date attached. According to the AI Pulse survey by JetBrains (opens in a new tab), taken between May and July 2026 among professional developers:
| Agent | Adoption | Up from (January 2026) |
|---|---|---|
| Claude Code | 39% | 18% |
| GitHub Copilot | 21% | 29% |
| Codex | 16% | 3% |
| Cursor | 12% | 18% |
Claude Code is today the most used and the one that grew most in absolute terms; Codex grew most in proportion, multiplying by five in half a year; Copilot is still second but falling; Cursor fell in usage even though three out of four developers know it.
Two warnings about these numbers. The first is that they come from a single survey: a signal, not a census. The second is that you will find headlines saying Codex passed five million weekly users —a figure from OpenAI, not from the survey— that do not measure the same thing: it includes people who do not code, and that is in fact the fastest-growing segment. Comparing it against Claude Code’s 39% is comparing different things.
What is worth deciding once
The practical corollary of the model becoming interchangeable is that what
you build around the agent is worth more than the agent. A well-written
AGENTS.md, fast tests and a repository that verifies itself work the same
in all four, and keep working when you switch.
That is the investment that is not lost. The choice of agent, by contrast, is reversible and you will probably revisit it in six months — because the numbers above will be different, but the question of how much you want to watch will be the same.
Comments
Sign in to comment and to like this article.
No comments yet. Be the first to write one.