The honest answer to "which AI coding tool is best" is annoying: it depends on the task. But that's not a cop-out — it's the finding of the largest real-world study we have, and it maps to a specific, buyable workflow. This is the task-by-task version.
Before the comparison, one framing that decides everything, borrowed from the flagship piece: don't buy on benchmark scores. Buy on cost per accepted production change — subscription plus credits plus retries plus your steering time plus cleanup plus review. A tool that tops a leaderboard but produces changes you have to redo is more expensive than a "worse" tool whose changes you merge. Keep that lens on as you read the numbers below.
Why "which is best" is the wrong question
A task-stratified analysis of 7,156 real pull requests — actual PRs opened by Codex, GitHub Copilot, Devin, Cursor, and Claude Code, scored on whether they were accepted and merged — found no universal winner. Different tools won different categories, by statistically significant margins. That single result should end every "X is the best coding agent" argument. The right question isn't which tool wins; it's which tool wins the kind of work you're doing.
Two more findings from that study frame the rest:
- Task type predicts acceptance more than tool does. Documentation PRs were accepted about 82% of the time across the board; new-feature PRs about 66% — a 16-point gap that dwarfs most tool-to-tool differences. What you ask for matters more than what you ask.
- The tools are still immature. A separate study of more than 3,800 reported bugs across Claude Code, Codex, and Gemini CLI found over 67% were functionality bugs, with API/integration/configuration errors the largest root cause. None of these are magic. All of them need your review.
The task-by-task decision table
From the PR-acceptance data, here's where each tool actually earned its merges:
| The work you're doing | Reach for | What the data shows |
|---|---|---|
| Shipping new features | Claude Code | Led the features category (~73% acceptance) and is strong on multi-file implementation. |
| Fixing bugs | Cursor | Led the fix category (~80% acceptance) — its in-editor, in-context loop suits targeted fixes. |
| Docs, comments, READMEs | Claude Code / Codex | Claude Code topped documentation (~92%); docs are the highest-acceptance category for everyone. |
| Broad, mixed, unpredictable work | Codex | The most consistent performer — strong across all nine task categories (roughly 60–89%), the safest single default when the work varies. |
| A steadily improving option | Devin | The only agent with a consistent positive acceptance trend over the study window — worth watching even if it's not your daily driver. |
The pattern is a multi-tool workflow, not a single-tool religion.
The three tools, by strength and feel
Claude Code — the terminal-native builder
Claude Code is a "pure agent" in the terminal: instructions, powerful tools, a model looping until done. It's strongest exactly where the data puts it — building features, multi-file implementation, refactors, and documentation — and it shines on TypeScript/React/Next.js-style work. It explores your repo with agentic search (glob/grep/read) rather than a pre-built index, which makes it excellent in unfamiliar codebases. The trade-offs: opaque usage limits and the occasional lockout, and a tendency to burn context if you let it wander. Make it your primary implementation agent, give it a bounded task, a repo, and tests, and it's hard to beat.
Codex — the best second seat
Codex's superpower in the data is consistency — it doesn't top every category, but it's strong in all of them, which makes it the safest default and the ideal second agent. Its highest-value role is delegated, parallel work: "review this PR," "write tests for this module," "find the auth bug," "try the same feature in a separate branch." Running Codex as a reviewer over Claude Code's implementation is the single best quality upgrade most solo builders can make — a second independent model that catches the first one's mistakes, and a hedge against a single vendor's lockout.
Cursor — the in-editor fixer
Cursor's win is fixes, and that tracks with what it is: an AI-native editor where the model works inline, in context, with your cursor. If you live in an editor — tab completion, inline edits, quick targeted changes — Cursor reduces friction in a way a terminal agent doesn't. The mental model that keeps you from overpaying: Cursor is an excellent interface layer, not proof that the underlying model is better. If your natural workflow is already a terminal agent, buying a high tier of Cursor on top is subscription stacking.
(Two honorable mentions: GitHub Copilot is no longer just autocomplete and is compelling if your world is GitHub-centered, at a low entry price. Gemini/Antigravity is a strong cheap high-context scout — good for reading lots of files and summarizing architecture — but I wouldn't make it primary until you trust its patch quality in your own repos.)
What they cost — and why the sticker price isn't the cost
Current entry pricing, for calibration:
| Tool | Entry | Higher tier |
|---|---|---|
| Claude Code (Max) | $100/mo (5×) | $200/mo (20×) |
| Codex (via ChatGPT) | $20/mo (Plus) | $100/mo (Pro, 5×) / $200 (20×) |
| Cursor | $20/mo (Pro) | $40/user/mo (Business) |
| GitHub Copilot | $10/mo (Pro) | $19–39/user/mo (Business/Enterprise) |
Now the important part: these numbers are the smallest term in the real cost. The subscription is fixed and knowable; the expensive variables are retries, your steering time, and cleanup. A $200 tool that lands changes you merge is cheaper than a $20 tool that produces changes you rewrite. Price the workflow by accepted changes per week, not by the line item on the invoice.
The benchmark caveat: don't buy on the leaderboard
If you're tempted to just pick whichever tool tops SWE-bench, don't. OpenAI stopped evaluating SWE-bench Verified after finding contamination and flawed test cases — a frontier model scored ~81% on Verified but only ~23% on the harder, fresher SWE-bench Pro. And a benchmark built on production iOS work, SWE-Bench Mobile, found the best agent-model configurations solved only 12% of tasks — and that agent design mattered as much as the model, with up to a 6× performance gap using the same model in different agents. The tool's harness — how it searches, plans, and self-verifies — is as decisive as the model inside it. Leaderboards can't see that. Merged PRs can.
The recommendation
If you want a default stack rather than a survey: Claude Code as your primary builder, Codex as your reviewer and second opinion, and Cursor if — and only if — you genuinely live inside an editor and mostly do targeted fixes. That's not fence-sitting; it's what the acceptance data actually supports. The teams getting the most accepted, tested, shipped changes per week aren't running one tool. They're running an implementer, a reviewer, and the discipline to make them check each other.
For the full reasoning on how to pick the model underneath these tools — and why cheap models quietly cost more — see the flagship guide.
FAQ
Is one of these clearly the best AI coding tool?
No — and that's the empirical finding, not a hedge. The largest study of merged PRs found no universal winner: Codex is most consistent, Claude Code leads features and docs, Cursor leads fixes. Match the tool to the task.
Can I just use one tool to keep it simple?
You can, and Codex is the safest single default because it's strong across every category. But the highest-quality setup is an implementer plus an independent reviewer — running one model over another's work catches mistakes a single tool won't.
Why not just pick the tool with the best benchmark score?
Because the benchmarks are a weak buying guide. A leading benchmark isn't a leading merge rate, contamination has inflated the popular ones, and agent design causes up to a 6× swing on the same model. Buy on accepted changes, not leaderboard rank — see the cost-per-accepted-change argument.
Is Cursor worth paying for if I already use Claude Code?
Only if you spend your day in an editor and do a lot of targeted fixes — that's Cursor's strength in the data. If you're a terminal-agent person, adding a high Cursor tier is usually subscription stacking rather than a real capability gain.
Where does GitHub Copilot fit?
It's the low-cost, GitHub-native option and it's grown well past autocomplete. If your workflow is centered on GitHub and price sensitivity is high, it's compelling — but for solo-founder build mode I'd still put Claude Code and Codex ahead of it.
Where to go from here
The tool question doesn't have a single answer, but it has a defensible workflow: implement with one agent, review with another, and pick per task rather than per hype cycle. That, plus buying on accepted changes instead of benchmarks, is most of the battle.
For the strategic layer — which model to run inside these tools, and the whole tokens-to-revenue picture — start with Which AI Model Should You Actually Use to Build Software?, then work with me or subscribe to the newsletter for more field notes from building in public.