Claude vs Codex vs Cursor vs Grok: the $200 Wrong-Seat Playbook

Four coding products keep getting ranked as one $200 model contest.

It is not a model contest but a routing failure: Cursor sells an interface, Claude Code a programmable harness, Codex an async sandbox, and Grok a model path. If the seat and job mismatch, teams lose hours today, ship regressions, and renew the wrong plan.

Which seat failed? Below is the tested 4-Seat Routing Checklist, exact matrix, and 15-step runbook.

Two names are terminal-first agents (Claude Code, Codex). One is an AI-native IDE surface (Cursor). One is a model and agent path from xAI (Grok), often consumed inside other products.

The product surfaces now make the split visible. Anthropic documents Claude Code as a terminal agent with programmable controls. OpenAI supports delegated Codex work in isolated cloud sandboxes. Inside its editor, Cursor exposes multi-file agent modes. Grok Build runs as an interactive or headless coding agent. [E1] [E2] [E3] [E4]

Keep one line: pick the seat, then pick the brand.

By the end you will have

1. The 4-Seat Routing Checklist as a one-page map you can paste into a team runbook
2. A layer map that separates interface, harness, and model before any brand argument
3. A standing protocol per seat, ready to drop into project instructions
4. A decision matrix keyed on job type rather than logo
5. A monthly test that tells you when the map has rotted into dogma

Why the Default Comparison Fails

The default approach is a clean logo table. Rows for features. Columns for brands. A green check under "agent mode" for everyone. This feels like analysis. It is not. It is a brand tournament.

Here is the problem in practice. After two weeks of "trying everything," you have three subscriptions, four prompt styles, and no shared rule for which tool owns which ticket. A multi-file migration hits, so you open Cursor because that is where you live. The agent chats. You thrash. You paste context again tomorrow. The missing piece was not intelligence. Deep-mission work landed in an interactive seat.

Real routing is not a bigger table. Map last week's jobs to seats and pick one primary. Add one secondary only when the hours justify it. Treat Grok as a model path until its harness earns a product row.

Layer Map: Interface, Harness, Model

Before brand preference, name the layer.

Interface layer. Where you stare. The clearest interface product in this set is Cursor: editor metaphor, multi-model picker, agent panels in the same window. Claude Code and Codex are CLI-first (with IDE and cloud surfaces growing). Grok shows up as model selection inside partners (including Cursor historically) and as Grok Build / Grok-oriented agent loops from xAI.

Harness layer. How the agent is allowed to plan, call tools, remember, stop, and verify. Public Claude Code workflows emphasize plan modes, hooks, skills, subagents, and long-session habits. The Codex product shape emphasizes sandboxed execution and async task delegation. In Cursor, the harness stays editor-native: the agent is a citizen of the buffer, not a guest process in another pane. Grok's harness is product-dependent: Grok Build vs model-in-Cursor are different animals.

Model layer. The weights: Claude family, OpenAI Codex/GPT coding stacks, whatever Cursor routes to, Grok coding models from xAI. Models move. Harnesses and interfaces lag. Switching models while keeping a broken harness produces another tournament post next month.

Operator rule: change one layer at a time. A quality failure points to the model or plan. Thrash points to the harness: hooks, stop rules, and verification loops. Flow friction points to the interface.

Seat 1: Claude Code - Programmable Terminal Harness

Claude Code fits work that looks like:

• Multi-file refactors with architectural judgment
• Long interactive sessions that need memory of prior decisions
• A harness you can program (skills, hooks, plan mode, subagents)
• You already live in a terminal and keep your own editor

Public comparisons in 2026 repeatedly frame Claude Code as developer-in-the-loop with deep codebase reasoning, not pure fire-and-forget. Community writeups cite multi-file quality and SWE-bench style scores that swing by model version; treat every percentage as as-of dated third-party, not eternal truth. What stays stable is product shape: terminal agent + programmable control surface.

Anti-pattern: force Claude Code into 20-line UI tweaks. You pay token cost for interactive depth an inline IDE agent finishes in seconds.

Standing protocol (paste into project instructions when this is primary):

SEAT: CLAUDE CODE (deep mission)
Before edits: name mission, constraints, done test, stop rule.
Prefer plan then execute. Log deviations in implementation-notes.md.
Do not start a second product agent for the same ticket without a handoff line.
End of session: one paragraph - what verified, what remains.

Claude Code pays rent when you name the mission, the verify loop, and the stop rule before it edits. Without that, you get a confident tour of the repo and a diff you do not trust.

Seat 2: Codex - Async, Sandboxed, Product-Wide

Codex fits work that looks like:

• Tasks you want to delegate and review later (PR-shaped work)
• Shell and systems work where sandboxing matters
• You already live in the OpenAI / ChatGPT product surface
• Throughput and isolation beat max local harness customizability

2026 comparison pieces often put Codex ahead on Terminal-Bench style agentic shell work and on sandbox narratives. They also note multi-surface distribution: CLI, IDE, cloud, ChatGPT app. Scores drift. The product thesis is stable: async delegation under isolation.

Anti-pattern: ask Codex for taste-heavy UI architecture with no design constraints, then blame the model for looking generic. Wrong seat.

Standing protocol:

SEAT: CODEX (async ticket)
Ticket must be PR-shaped: goal, constraints, done test.
Prefer sandboxed / delegated run over pair-programming a design exploration.
Stop after first review cycle unless told to continue.
Eager subagent spawning is a routing defect. Lower the reasoning level or require explicit spawn permission in AGENTS.md.

Codex pays rent when the ticket is spec to sandbox to PR, not when the ticket is a 40-minute design exploration.

Seat 3: Cursor - the All-Day Interface

Cursor fits work that looks like:

• You live in the editor eight hours a day
• You want multi-model access without leaving the buffer
• Inline edit, multi-file select, and visual diff review are the main loop
• Team review and IDE-native agent UX matter more than terminal purity

Cursor is not "worse Claude Code." It is a different primary mode: editor-first assist, not terminal-first delegation. 2026 roundups still list Cursor as the default AI-native IDE for interactive development. Model choice inside Cursor is a feature: Claude, OpenAI, Grok-class models, and others can rotate while the interface stays fixed.

Anti-pattern: expect Cursor alone to own a week-long migration with no harness stop rules. It can help. It is not the same control plane as a terminal agent with hooks and skills.

Standing protocol:

SEAT: CURSOR (interactive edit)
Default for keystroke-to-diff work and selection-context edits.
For migrations >3 files or multi-hour missions, hand off to terminal harness seat with a one-line brief.
Model swaps happen here first (including Grok) before buying a second product.

Cursor pays rent when keystroke-to-diff latency and visible selection context matter. Pair it with a terminal agent for jobs that should leave the editor.

Seat 4: Grok - Model Path, Not a Fourth Religion

Grok fits work that looks like:

• You want xAI coding models for speed or cost on agentic loops
• Your interface already supports Grok (Cursor partners, Grok Build, other IDEs historically)
• You are prototyping fast and want short iteration cycles

As of July 2026, xAI public posts position Grok 4.5 for coding and agentic tasks, including training collaboration notes with Cursor and Grok Build as a CLI-oriented surface. Earlier Grok coding models launched with multi-IDE partner free periods. That history matters: Grok often arrives as a model option inside someone else's harness, not as a full parallel OS you must adopt wholesale.

Anti-pattern: treat "Grok" as a complete replacement for Claude Code's skill stack or Cursor's editor product. The model still needs an interface and an execution harness.

Standing protocol:

SEAT: GROK (model path first)
Trial as a model option inside the primary interface before adopting a second product.
Test Grok Build as a harness-and-model pair against async or deep-mission tags, not "vibes in chat."
Do not add Grok as a third paid coding agent until primary + secondary seats have two weeks of handoff rules.

Evaluate Grok on a fixed harness and fixed tasks. A brand-new workflow adds an uncontrolled variable, so the result measures the workflow as much as the model.

Mechanism Dive: Why Brand Tournaments Fail

The comparison fails because product boundaries cut across layers.

Job graph (stable)
 interactive edit -> interface seat (often Cursor)
 deep multi-file -> harness seat (often Claude Code)
 async sandboxed -> harness seat (often Codex)
 model swap only -> model seat (Claude / OpenAI / Grok / ...)
 
Brand graph (unstable)
 Claude Code = strong harness + Claude models + terminal UX
 Codex = multi-surface product + OpenAI models + sandbox story
 Cursor = interface + multi-model router + editor agents
 Grok = xAI models + partner surfaces + Grok Build path

"Cursor beat Claude Code" means little without the task class. Interactive UI polish and a 30-file migration test different seats. "Codex is faster" also needs a unit: wall-clock time on a sandboxed ticket or judgment on an ambiguous architecture call.

Mismatch cost has two signatures:

1. Over-autonomy - terminal agent rewrites half the repo for a three-line fix.
2. Under-autonomy - IDE chat back-and-forth for a job that should have been a sandboxed PR with tests.

The checklist exists to kill mismatch cost, not to crown a monarch.

Worked Example: Three Weeks, One Stack Inflation

Week 0 - the mess. A two-person team renews Cursor for daily work. A comparison thread pushes Claude Code into the stack, while an existing ChatGPT plan makes Codex feel free. No hour inventory. No handoff rule. Grok is "on the list" for next month.

Week 1 - inventory only. They tag last week's tickets using an illustrative mix, not a market average. Most hours went to interactive edits, about a quarter to deep multi-file work, and the remainder to async PR-shaped tickets. Primary seat becomes Cursor. Secondary becomes Claude Code for missions over three files. Codex is paused for two weeks - not deleted from the account - only removed from the default path. Grok stays a model option inside Cursor if available.

Week 2 - handoff line. Every deep ticket starts with one line: "Seat: Claude Code. Done test: typecheck + smoke. Stop after plan if architecture fork." Interactive polish stays in Cursor. They stop pasting the same context into three UIs.

Week 3 - measure. Three tickets where the seat rule changed the outcome.

A migration that would have been chat thrash in Cursor completed under Claude Code with a stop rule. A one-line CSS fix that would have burned a terminal session finished in Cursor in minutes. An async bugfix that would have interrupted deep work went to a PR-shaped Codex run later that day.

That is the value of the system in one sentence. The third month does not rediscover the same stack fight, because the first two weeks compressed the lesson into a routing rule that surfaces at ticket time.

Magnet: 4-Seat Routing Checklist

Name: 4-Seat Routing Checklist. Use this when you are about to pay for, standardize, or argue about a coding AI tool.

A. Job inventory (10 minutes)

1. List last week's coding tickets (real work, not vibes).
2. Tag each: interactive edit / deep mission / async ticket / model-swap experiment.
3. Count hours per tag. The largest tag owns the primary seat.

B. Primary seat pick (one only)

4. Interactive hours dominate - primary = Cursor (or equivalent IDE).
5. Deep mission hours dominate - primary = Claude Code (or equivalent terminal harness).
6. Async ticket hours dominate - primary = Codex (or equivalent sandboxed agent).
7. Model novelty is the only motive - keep the primary seat and A/B the model layer only.

C. Secondary seat (optional, max one)

8. Add a secondary only if it covers a tag that is a meaningful share of hours (rule of thumb: about one day in five).
9. Write the handoff rule in one line (example: "Cursor for inline; Claude Code for migrations >3 files").
10. Forbid a third paid coding agent until the handoff rule has been used for two weeks.

D. Grok rule

11. Trial Grok as a model option inside the primary interface before adopting a second product.
12. Score Grok Build as a harness-and-model pair against async or deep-mission tags.

E. Verify loop (non-negotiable)

13. Every agent task gets: goal, constraints, done test, stop rule.
14. Prefer tests, typecheck, or a scripted smoke over "looks good."
15. Log one failure per week: wrong seat or wrong prompt. Fix the map before you rewrite the prompt.

You should see: a one-page map with a primary seat, optional secondary, model options, and handoff rules. A map that cannot fit on one page is still a tournament table.

Decision Matrix

Primary seat by job type.

Interactive edit: Cursor primary. Deep multi-file: Claude Code primary. Async sandboxed ticket: Codex primary. Model swap only: stay on current interface; trial Grok or others as drop-in.

Failure Modes to Watch For

Stack inflation without inventory. Three logos, zero hour tags. Fix: week-one inventory only - no new installs.

Primary seat never written down. Everyone "knows" until a fight in Slack. Fix: one line in the team runbook.

Handoff rule missing. Cursor owns migrations by accident. Fix: step 9 as a literal paste in tickets.

Grok as a third religion. New product before primary/secondary stabilize. Fix: model path first for two weeks.

Never measuring. Routing becomes dogma. Fix: monthly three-ticket value test (below).

Benchmark cosplay. Treating SWE-bench screenshots as a personality test. Fix: use benches as scent; use hour mix as law.

When Not to Use This Playbook

• You only need autocomplete in one editor and never run agentic loops - buy the simplest seat and stop reading comparison threads.
• Enterprise SSO, data retention, or on-prem rules force a vendor - comply first, route inside the allowed set.
• You are not willing to tag one week of real tickets - the checklist will become fan fiction.
• Open-source agents (Cline, OpenCode, Aider, Hermes, and friends) can replace seats if you supply models and accept harness work - same seat logic, different logos.

Setting This Up Over Four Weeks

Start smaller than you want to. Do not install four agents on day one and expect the map to appear.

Week 1 - write inventory only. Tag tickets. No new subscriptions. Get comfortable distinguishing interactive edit from deep mission from async PR work.

Week 2 - pick primary + paste one seat protocol. Install or keep only what the primary needs. Put the standing protocol in project instructions.

Week 3 - add secondary only if hours demand it. Write the one-line handoff. Run three real tickets through the rule.

Week 4 - first measure pass. Use the monthly test below. Tighten tags or protocols based on what failed.

By week five or six the fight should be quieter: not because the brands got dumber, but because the seat map surfaces before the logo does.

Measuring Whether the System Still Earns Rent

A routing map nobody audits becomes dogma, then rot.

Monthly test. Pick three tickets from the past month where a seat rule applied. Compare each outcome with the plausible result from the alternate seat. No real difference in at least two of three means the tags are wrong or the handoff line is fiction. Fix the map. Do not buy another logo.

Inverse test. Look at your secondary seat. No related use in a month has two common causes. First check whether the hours justified the seat; drop it when they did not. Then inspect the handoff rule and add it to the ticket template when it stayed invisible.

This monthly check is the habit that separates a routing system that compounds for a year from a two-week opinion that dies after the next viral comparison thread.

Honest Limits

• This is not a lab bakeoff with controlled tokens and identical repos. Public benchmark numbers disagree across articles and change with model IDs. Treat them as directional evidence, not a verdict.
• Pricing tiers ($20 vs $200 class plans) shift. Optimize for hour mix and failure cost, then check price. Temporary product footguns (eager subagents, Ultra modes, fast multipliers) need "for now" labels when you write field notes about a specific UI.
• Field-note date: the seat map below is scored as of July 2026. Re-score it when your hour mix changes.

Interface is where you stare. Harness is how it is allowed to act. Model is what thinks. Brands bundle those layers unevenly.

Your next action: run the 4-Seat Routing Checklist on one real ticket this week and name its seat - interactive, deep-mission, or async.

Evidence

• [E1] Anthropic: Claude Code overview and product documentation: https://docs.anthropic.com/en/docs/claude-code/overview
• [E2] OpenAI: Codex product overview and cloud delegation: https://openai.com/codex/
• [E3] Cursor: Agent modes for autonomous exploration and multi-file edits: https://docs.cursor.com/agent
• [E4] xAI: Grok Build overview for interactive, headless, and ACP use: https://docs.x.ai/build/overview

Get the next field note

I publish practical field notes for builders running agents in production - what shipped, what broke, and the system behind it.

Get the next one free: https://nyk.dev/#newsletter

Free. Unsubscribe anytime.

Join the private NYK alpha channel for early notes and updates: https://t.me/+GJ-FEpzcZrtmMTky

Follow @nykdotdev for the daily build in public.