This article was originally published on aicoderscope.com
You can have both terminal coding agents for $40 a month. That's the same price as one Cursor Teams seat. The question most developers actually face isn't "Codex or Claude Code" — it's which one deserves to be your first install, and what you lose if you only pay for one.
Both tools launched their current generation in April 2026. Both run in your terminal. Both cost $20/month at the entry tier. And they're measuring neck-and-neck on SWE-bench Verified: GPT-5.5 at 88.7%, Opus 4.7 at 87.6%. The 1.1-point spread is noise, not signal.
The meaningful differences are architectural, and they dictate which tool wins on which jobs.
What the $20 tier actually buys you
| Claude Code Pro ($20/mo) | Codex CLI on Plus ($20/mo) | |
|---|---|---|
| Entry price | $20/mo ($17 annual) | $20/mo (ChatGPT Plus) |
| Model | Claude Opus 4.7 | GPT-5.5 |
| Context window | 200K tokens | 400K tokens |
| Quota model | Monthly usage cap | Rolling 5-hour window caps |
| Next tier up | Max 5x — $100/mo | Pro 20× — $200/mo |
| Mid-range tier | Yes ($100/mo Max 5x) | No (jumps to $200) |
| Platform (full native) | macOS, Linux, Windows (v2.1.120+) | macOS, Linux |
| Windows status | Full (no Git Bash required) | Experimental |
| Open source | No | Yes (MIT) |
The gap that stings most at $20 is context. Codex ships 400K tokens on the Plus plan — double the usable context in Claude Code Pro. That matters for large-file refactors where Claude Code Pro is more likely to ask you to break the task into smaller chunks.
The gap that saves you money at the mid-range is Claude Code's $100/mo Max 5x tier. OpenAI has no $100 option: it's Plus at $20 or Pro at $200. If you're a heavy user but not a heavy heavy user, Claude Code has a stopping point that Codex doesn't.
Architecture: where the real split is
Both tools are agentic — they plan, execute multi-step tasks, read your codebase, and commit changes. The execution model is completely different.
Claude Code is local-first and interactive by default. When you run claude, it presents a structured plan, shows you which files it will touch, waits for your approval, then executes. The loop keeps you in the conversation. Complex ambiguous requirements — "refactor this module to use the repository pattern" — benefit from this model because Claude Code asks clarifying questions before writing code. That extra round-trip catches edge cases that pure autonomous execution would miss.
The /batch command flips this into parallel mode: Claude Code decomposes a task into 5–30 independent units, each in its own isolated git worktree, with a coordinating lead agent merging the results. A batch of 20 endpoint documentation tasks takes roughly the same wall-clock time as one. This is Claude Code's primary speed lever.
Codex CLI is sandboxed-async by design. Three autonomy levels let you set how much supervision the agent needs before it runs:
- Suggest mode: every edit and shell command requires your approval. Right for production codebases.
- Auto-edit mode: file changes apply automatically; shell commands still prompt. Right for feature branches.
- Full-auto mode: no confirmations within the sandbox boundary. Right for well-scoped, isolated tasks.
The workspace-write sandbox (default in full-auto) restricts Codex to your working directory and routine local commands — edits outside that boundary still require approval. You can move to danger-full-access when a task needs external services, but that's the exception.
Where this pays off: Codex in full-auto mode is faster for bulk tasks that don't need clarification. "Write unit tests for all functions in this module" runs unattended, start to finish. Claude Code's default interactive mode would pause for plan approval. If you already know exactly what you want and the task is well-scoped, Codex's three-mode system gets out of your way more cleanly.
Benchmarks: the three numbers that actually matter
The single benchmark question — which model is smarter? — has a more complicated answer than the headline SWE-bench scores imply.
SWE-bench Verified evaluates real GitHub issue resolution on issues that human reviewers have confirmed are solvable. GPT-5.5 scores 88.7% (OpenAI-reported, April 2026). Opus 4.7 scores 87.6% (Anthropic-reported, April 2026). Different testing harnesses, different agentic scaffolds — the 1.1-point gap should be treated as tied.
SWE-bench Pro is the harder, newer variant: issues from repositories updated after most LLM training cutoffs, so memorization helps less. Here Opus 4.7 leads at 64.3% versus GPT-5.5 at 58.6% — a 5.7-point edge. For teams working on recent frameworks and libraries that don't appear heavily in training data, this gap is meaningful.
Terminal-Bench 2.0 measures CLI-specific capabilities: multi-step command-line workflows, tool coordination, and planning across turns in a pure terminal context. GPT-5.5 scores 82.7% (#1 on the leaderboard). Opus 4.7 is not ranked. This is Codex CLI's home turf, and the performance advantage for DevOps-heavy workflows is real.
The takeaway: Opus 4.7 wins on complex, newer code. GPT-5.5 wins on terminal-native tasks. Neither model is definitively better; each is better at what it was optimized for.
Three scenarios where the choice is clear
Scenario 1: You're a backend engineer refactoring a 40-file payment service.
The task spans many files with subtle interdependencies. You'll have questions partway through — "should I keep the legacy retry logic or remove it?" — and the answer changes which files get touched.
Claude Code wins here. The interactive loop is a feature, not overhead. Opus 4.7's SWE-bench Pro advantage on recent code kicks in. The /batch command handles the integration test generation once the refactor is scoped. Claude Code's 1M context window (available on the $100 Max 5x plan) lets it hold the entire service in context without chunking.
Scenario 2: You're automating code quality in CI — lint fixes, docstring generation, test file creation for new functions.
These tasks are well-defined, repetitive, and don't need human supervision. The codebase is under version control with clean rollback.
Codex CLI wins here. Full-auto mode runs without pausing. AGENTS.md defines the rules once; every CI-triggered run inherits them. The 400K context handles large files without the overhead of a Max plan upgrade. Codex Cloud (via the macOS app) can run these tasks as scheduled overnight batches in OpenAI's infrastructure, independent of your local machine.
Scenario 3: You're a solo dev prototyping a new feature on a Friday afternoon.
You want real-time feedback, fast iteration, and the ability to course-correct quickly. You're making architectural decisions as you go.
This one is genuinely a toss-up that comes down to whether you're on macOS/Linux (both equal) or Windows (Claude Code wins on parity), and whether the task is well-defined (Codex) or exploratory (Claude Code). The Terminal-Bench gap shows up in scripting tasks; the SWE-bench Pro gap shows up in complex code logic. Neither is a blowout.
Ecosystem: the lock-in you're actually buying
This is the comparison that matters most for teams planning a 6-month tool consolidation.
Claude Code runs on CLAUDE.md — project and user-level instruction files that support layered configuration (project root → ~/.claude/ → local override), hooks for auto-formatting and blocking destructive commands, and MCP server connections. Teams that invest in this system — structured test commands, domain-specific code review checklist, automated PR triggers — get compounding returns. The /ultrareview command (launched April 2026) fires a cloud fleet of bug-hunting agents that deposit findings into your CLI session. Routines schedule recurring tasks on Anthropic's infrastructure, running on a calendar or GitHub event even when your machine is off.
None of this is accessible from Codex CLI b
Top comments (0)