Claude Code vs Cursor: which one, for which job (and where Codex fits).

Strip the discourse and five dimensions decide it. None of them is "which model is smarter" — that question dissolved when both tools started shipping the same frontier models within days of release.

Long-horizon autonomy. The defining receipt in this book isn't a snippet completion — it's Ch 45: Claude Code one-shot a full native SwiftUI app for LinguaLive, every line of a language I can't read, and the proof is a RevenueCat row where a $7.99 purchase became a renewal. That's the shape of work the terminal harness is built for: hand it a brief, let it run, review the finished thing. The discipline that keeps those runs safe — a goal, a diff ceiling, a stop condition — is Ch 38.

Parallelism. One Cursor window is one pair of hands. Claude Code fans out — Ch 6 is the reference for the parallel-subagent patterns, Ch 20 for running parallel sessions across git worktrees — four panes, four agents — without them stepping on each other. The swarms page carries the live patterns. An IDE's inline loop has no equivalent of "fourteen agents, each reading a slice of the repo, report back."

Enforcement, not preference. Hooks (Ch 16) turn rules into code that runs on every tool call — a lint gate the agent can't talk its way past. Context files are suggestions; hooks are law. That distinction is what lets you leave an agent running while you do something else.

Headless and CI. claude --print runs in a pipeline with no human at the keyboard (Ch 18). The same harness that pairs with you in the morning runs your CI checks at night. An IDE can't follow you into a GitHub Action.

One model-layer signal, read with the standing discipline: the Fable 5 launch table puts Terminal-Bench 2.1 at 88.0% — against 83.4% for GPT 5.5 through Codex CLI. A signal that terminal-harness agentic work is where this model family is strongest, not proof; Ch 24's benchmark discount applies, and your private eval is the receipt (Ch 25).

No strawman here — the IDE-first shape has honest advantages, and pretending otherwise would make this page useless to you.

Visual diff review, in place. Reviewing an edit in the buffer where it lands — syntax-highlighted, in context, accept or reject per hunk — is a better review surface for small and medium edits than reading a terminal diff. Claude Code's answer is "review the PR," which is right for a 40-file run and clunky for a 4-line one.

IDE ergonomics stay yours. Your keybindings, your jump-to-definition, your debugger — the agent moved into your house instead of asking you to move into its terminal. For developers whose flow is built around an editor, that continuity is worth a lot.

Activation energy. An IDE-native developer is productive in Cursor in minutes. Claude Code asks you to accept a terminal contract first — permissions, context files, a different review rhythm. That's a real onboarding tax, and pretending it's zero is how evangelists lose rooms.

They run their own evals. CursorBench is Cursor grading frontier models on its own internal benchmark before shipping them — which is exactly the private-eval discipline Ch 25 argues every operator should copy. A tool vendor that doesn't trust public leaderboards is a tool vendor thinking clearly.

The honest summary: if your work is mostly in-editor iteration on a codebase you know — and you want to watch every edit land — Cursor is the right default. The case for the terminal only opens when the work outgrows the buffer.

The versus framing collapses once you meet the third tool. Ch 35's answer to "Codex or Claude Code?" is neither — it's shifts. Codex works the night: it watches Sentry, catches the 3 AM null-pointer, opens a PR with a test on its own branch, posts one line to Slack, goes back to watching. Claude Code drives the day: features, migrations, the architecture argument. Same repo, same .mcp.json, same CLAUDE.md — two agents, two contracts, one hand-off.

And the scale receipt, because "second agent" sounds like a toy until you see one at full size: Ch 43 documents a Codex run pointed at Folderly with one constraint — simplify, follow the design system. It deleted a net 91,874 lines across 718 files, 243 commits on the branch, 106 of them beginning with "Simplify," 27 of them hardening commits — all behind real build, CI, browser, and API checks. That run cost 46% of one week's usage, and it still needed a human hand on the wheel mid-run telling it to checkpoint. The loop discipline that makes this safe — worktree per fix, evaluator gates, the human as the only door to main — is Ch 42.

The reason to run a second prior isn't capacity. It's that a different model reaches for different edge cases — Codex proof-checks Claude Code's diffs by running the tests CC didn't think to run. Best execution is a second opinion plus a proof check, never one agent trusted blind.

My split, from Ch 35, unchanged since it shipped: Claude Code is the day driver — it's where I bring opinion, where the swarm runs, where headless mode runs CI. Codex is the night shift — incident response from logs, regression catching, doc updates that lag the code. The work it does best has a tight scope, a clear signal, and a deterministic test. The moment the contract gets fuzzy — a nine-file PR, an architecture call — I close it unread and reopen the problem in Claude Code, where I can argue.

Three rules keep the shifts from stepping on each other. Branch protection on main — Codex never pushes there, enforced at the GitHub level, not the social one. File ownership written into CLAUDE.md — both agents read the contract before their first tool call. And no agent merges its own PR, ever. That last rule has a bill attached: a Codex auto-merge I'd permitted during a maintenance push and forgotten to revoke once suppressed an exception that was the only signal a customer's SMTP creds had rotated. Eleven days to notice. The customer churned.

Two things that make the setup cheaper than it sounds. Both agents share one .mcp.json and one CLAUDE.md — no second source of truth to drift. And since May 2026 the SKILL.md format is cross-vendor: the same skill file fires in both CLIs, so the skill library is written once.

Where's Cursor in this? Honestly — nowhere, and that's a fact about my workflow, not a verdict on the tool. My day-driver seat went to the terminal because my work skews long-horizon and parallel. Nothing in the shift contract cares which harness fills the day seat. If yours is Cursor, keep the contract and swap the chair: branch protection, file ownership, human merge. The architecture survives the substitution; that's how you know it's the architecture doing the work, not the brand.

No closing framework. The tools will leapfrog each other again before this page needs updating — both rode Fable 5 within a day of launch, and the tier list stays the live ranking. The thing that won't move: you're not picking a winner, you're staffing a shop. Seats, contracts, and one human gate.