Codex CLI vs Claude Code: Head-to-Head After 3 Months of Real Use

After three months of running both tools against the same codebase — a mid-size Python/FastAPI backend with ~85,000 lines of code and a React frontend — the winner depends entirely on the task type, not the marketing copy. Here is the honest breakdown.

What Are Codex CLI and Claude Code, Exactly?

OpenAI Codex CLI is a terminal-native coding assistant released in April 2026, powered by the o4-mini model by default (with optional o3 for harder reasoning tasks). It operates in three modes: suggest (outputs a diff), auto-edit (applies diffs automatically), and full-auto (runs shell commands too). Per OpenAI’s Codex CLI documentation, it sandboxes command execution and requires explicit approval before writing to disk in default mode.

Claude Code is Anthropic’s agentic CLI tool, open-sourced under Apache 2.0 in 2025. It uses Claude Sonnet 4.6 as its primary model (with Claude Haiku 4.5 available for lighter tasks). Unlike Codex CLI, Claude Code is designed around multi-turn agentic sessions: it reads files, runs tests, interprets failures, and loops until a task is done — or until it hits a context or tool-call limit. Available as part of Claude Pro ($20/mo) and Claude Max ($100/mo) plans, with Max providing roughly 5× higher usage limits per Anthropic’s pricing page.

We tested both tools on five representative engineering tasks. The methodology: same task brief, same starting codebase commit, one human reviewer scoring correctness, files-touched efficiency, and test pass rate. No cherry-picking.

Task 1 — Module Rename Across 200 Files: Claude Code Wins

The task: rename the internal user_auth module to auth_core across ~200 Python files, updating all imports, config references, and one Alembic migration file.

Claude Code completed the rename in a single session — it used a grep-first pass to map all references, then applied edits in batches. The one miss: a dynamic import in a Celery task file that used a string-based module path. It flagged this as a potential problem in its summary, which saved a production incident. Files touched: 212. Errors on first test run: 1 (the Celery dynamic import).

Codex CLI in full-auto mode missed 14 files in the first pass, requiring two manual correction rounds. It also touched 7 unrelated files — a configuration parsing module it incorrectly identified as relevant. Files touched: 233. Errors on first test run: 9.

Winner: Claude Code. The repo-wide context traversal is meaningfully better on cross-file symbol work.

Task 2 — Writing Unit Tests for an Async FastAPI Endpoint: Codex CLI Wins

The task: write pytest-asyncio unit tests for a paginated /orders endpoint, covering happy path, empty result, invalid cursor token, and 401 unauthorized cases.

Codex CLI’s o4-mini reasoning model produced four correct test cases in a single pass with proper AsyncClient setup and pytest.mark.asyncio decorators. Token cost: approximately $0.004 at o4-mini pricing per OpenAI’s API pricing page. Elapsed time: 23 seconds.

Claude Code produced the same four tests but also added a fifth edge case (malformed JSON body returning a 422) and a shared fixture file. Useful additions — but they required a follow-up review pass and doubled the diff size. For a scoped task where you know exactly what you want, Codex CLI’s tighter output wins.

Task 3 — Debugging a Race Condition in Node.js: Rough Draw

The task: a Node.js EventEmitter-based queue was occasionally processing the same job twice under high concurrency. Reproduce and fix.

Both tools identified the root cause — a missing lock on the processing Set before the async gap between emit and the listener callback. Neither tool actually reproduced the race in testing (flaky by nature). Claude Code proposed using a Map<string, Promise> deduplication pattern and wrote the implementation. Codex CLI proposed a Redis-based distributed lock, which is architecturally heavier than the problem required.

Claude Code’s solution was production-appropriate for the scale; Codex CLI’s was over-engineered. Edge for Claude Code on this one, but not a clean win.

Task 4 — Adding Cursor-Based Pagination to a REST API: Tied

The task: replace offset-based pagination on three GET endpoints with cursor-based pagination using base64-encoded last-record IDs. Update the OpenAPI spec and the frontend fetch hooks.

Both tools produced functionally correct implementations. Claude Code modified all three endpoints, the OpenAPI schema, and two React hooks in a single session. Codex CLI required two separate invocations — one for the backend, one for the frontend — because it doesn’t maintain session context across directories as naturally. Total wall-clock time: 18 minutes (Claude Code) vs. 24 minutes (Codex CLI including context reloading). Both solutions passed the existing test suite.

We ran both implementations against the same evaluation rubric we used in our June 2026 coding agent rankings — and the pagination task is where cross-directory agents consistently outperform single-file completers. Claude Code’s session continuity is the differentiator.

Task 5 — REST-to-GraphQL Migration for a Single Resource: Codex CLI Wins on Speed

The task: migrate the /products resource from REST to GraphQL using Strawberry (Python). Keep the REST endpoint live in parallel; add GraphQL schema, resolver, and one integration test.

Codex CLI finished in 11 minutes and produced a clean Strawberry schema, a working resolver using the existing SQLAlchemy model, and a valid pytest integration test. Zero manual corrections needed.

Claude Code took 19 minutes and added a DataLoader for N+1 prevention — correct and impressive, but unsolicited. The DataLoader implementation also introduced a dependency on strawberry-django (not in our requirements), which broke the CI pipeline until we reverted it. When Claude Code goes agentic on a clearly-scoped task, it sometimes over-architects.

Benchmark Context: Where Do These Tools Sit?

Per Anthropic’s SWE-bench Verified report, Claude Sonnet 4.6 — the model powering Claude Code — scores 72.7% on SWE-bench Verified, a standard software engineering benchmark covering real GitHub issues. Per OpenAI’s model evaluation page, o3 (available in Codex CLI with the --model o3 flag) scores 71.7% on SWE-bench Verified. These headline numbers are close enough that task framing and tool architecture matter more than raw model capability for most real-world engineering work.

What SWE-bench doesn’t measure: the multi-turn session quality (reading test output, adjusting, re-running) that makes or breaks agentic tools. That’s where Claude Code’s loop-until-done architecture shows up in daily work.

“We designed Claude Code to keep working until the tests pass, not just until it writes a plausible edit.” — per Anthropic’s Claude Code launch documentation

This design philosophy is visible in the test results above. It’s also the source of its main failure mode: the tool sometimes keeps working past the point where a human would stop and ask a clarifying question.

Cost Comparison: What Does Each Tool Actually Cost?

The cost math for an individual developer doing 3–4 coding sessions per day: Codex CLI at o4-mini pricing runs roughly $15–40/month in API costs depending on session depth. Claude Code on Max is $100/month flat but removes the per-session cost anxiety that causes developers to cut sessions short. For teams, Codex CLI’s pay-per-token model scales more predictably.

Which IDE Integration Is Better?

Neither tool requires an IDE — both are CLI-first. But integration quality matters for context loading:

Codex CLI drops into any shell and works with any editor. Its --cwd flag scopes it to a specific directory, and it reads .codexignore files to exclude vendor directories. No IDE plugin required.

Claude Code integrates with VS Code and JetBrains via official extensions (installed via Claude Code’s built-in installer), which surface its output directly in the editor diff view and let you approve or reject edits file-by-file. The extensions also enable CLAUDE.md project context files, which persist tool behavior rules across sessions — the closest thing either tool has to project-level memory.

The Gemini CLI vs Claude Code comparison we ran in 2026 found that persistent project context (via CLAUDE.md) was one of Claude Code’s most underused features — teams that invest 30 minutes in setting it up see measurably fewer unsolicited dependency additions and off-brief edits.

The Failure Modes You’ll Actually Hit

After 90 days, these are the real failure modes, not the marketing edge cases:

Claude Code: Context window saturation on large repos (500K+ LOC) causes silent file-scan clipping. The model doesn’t error — it just stops looking at files it hasn’t scanned yet and proceeds with incomplete information. Symptom: edits that pass unit tests but miss callers in untouched directories. Mitigation: use /compact mid-session or scope each session to a single module.

Claude Code: Multi-turn sessions occasionally get stuck in a fix-revert loop where the model alternately introduces and removes the same line, burning context without progress. Trigger: ambiguous test failure messages where the root cause is outside the file being edited. You will not always notice this until the session ends with no net change. Check git diff after any session longer than 20 turns.

Codex CLI: In full-auto mode, the approval prompt cadence is disruptive on multi-file tasks — it asks for confirmation before each file write, which breaks flow. Workaround: use --approval-mode=none in a sandboxed environment only.

Codex CLI: The o4-mini model hallucinates library APIs that don’t exist in the installed version. This is particularly common with FastAPI versions 0.110+, where some parameter names changed. Always run pip install -r requirements.txt && python -m pytest immediately after any Codex CLI session.

We documented these patterns alongside a broader survey in our Claude Code vs Cursor comparison, which covers a different competitive angle — Cursor’s autocomplete-first approach vs. Claude Code’s agentic loop.

The Verdict: Which Tool for Which Developer?

Use Claude Code if: you do substantial refactoring, feature development, or cross-file work; you want persistent project context that reduces repetitive briefing; and you’re on a subscription budget that works better than per-token billing.

Use Codex CLI if: you want tight, scoped edits where you control the exact scope of each change; you prefer pay-per-use economics; or you need shell-native integration without IDE dependencies.

Use both — the practical answer for a 3-month-in developer: Claude Code as the primary agentic tool for anything requiring multi-file awareness, Codex CLI with o3 for targeted test generation and scoped edits where you want a smaller, faster model.

FAQ

Is Claude Code better than Codex CLI for beginners?

Claude Code is generally easier for beginners because its agentic loop handles more of the workflow — it reads files, runs tests, and interprets failures without requiring you to manually sequence those steps. Codex CLI gives more control but requires you to understand what you want before you ask.

Can I use Codex CLI without an OpenAI subscription?

Codex CLI requires an OpenAI API key and bills per token. There is no flat-subscription access; you pay for what you use. At o4-mini pricing per OpenAI’s API pricing page, light daily use typically runs under $20/month for individual developers.

Does Claude Code work offline?

No. Claude Code is a cloud-based tool — every request is sent to Anthropic’s API. The CLI and VS Code extension are client-side, but the model inference is remote. If your environment has strict air-gap requirements, neither Claude Code nor Codex CLI is suitable without a self-hosted model setup.

What’s the SWE-bench Verified benchmark and why does it matter?

SWE-bench Verified is an evaluation suite of real GitHub issues across popular Python repositories (Django, Flask, NumPy, etc.). Models are scored on whether they produce code changes that resolve the issue and pass the project’s test suite. It’s the most credible publicly-available coding benchmark because the tasks are drawn from real production codebases, not synthetic puzzles. Per Anthropic’s model card, Sonnet 4.6 scores 72.7%; per OpenAI’s evaluation page, o3 scores 71.7%.

Can Claude Code and Codex CLI be used together in the same project?

Yes. A common workflow: use Claude Code for initial feature development and cross-file refactoring, then switch to Codex CLI for generating tests on the completed feature. The tools don’t share session context, so you will need to re-brief each tool on the relevant code.

What happens when Claude Code hits its context limit mid-session?

It displays a context warning and prompts you to run /compact (which summarizes prior conversation to free window space) or start a new session. The risk: if you ignore the warning and continue, the model operates on a truncated view of the codebase. Always check which files were included in the last read before proceeding past a context warning.

Last updated: 2026-07-17