How to Use Claude Code and Codex Together on One Project

Dual-tool use stopped being exotic sometime in the past year. The clearest signal: OpenAI ships an official Codex plugin for Claude Code, announced on the OpenAI community forum. When one vendor builds an integration into the other vendor's CLI, running both is no longer a hack, it is an acknowledged workflow. If you are still deciding between them, start with our head-to-head in Claude Code vs Codex; this guide is for the growing group that answered “both.”

The benchmark picture reinforces the split rather than settling it: Claude Fable 5 holds the top published SWE-bench Verified score (95.0%), while GPT-5.6 Sol posts OpenAI's best terminal-agent numbers (Terminal-Bench 2.1: 88.8%). Neither dominates the other across every axis, which is exactly the situation where owning both pays. Tier-picking guides: best Claude model and best Codex model.

These three patterns recur across dev communities as the dual-tool workflows people stick with. All of them share one mechanism: a shared task file, usually task.md or a task section in AGENTS.md, that acts as the contract between the two tools. One agent writes to it, the other reads from it, and you arbitrate.

Recipe 1: Planner / implementer split

1. 1

   Claude plans

   Open Claude Code on the repo and have it explore the codebase and draft a plan into task.md: files to touch, the approach, acceptance criteria, and explicit exclusions. This plays to the explorer role, deep reading before any writing.
2. 2

   Codex implements

   Open Codex in the same repo (ideally a fresh branch), point it at task.md, and tell it to implement exactly what the file says, nothing more. The executor gets a bounded, written scope instead of a vague verbal brief.
3. 3

   Claude reviews

   Back in Claude Code, have it diff the branch against task.md: does the implementation match the plan, did anything out of scope change, do the acceptance criteria hold? “Claude plans, Codex implements, Claude reviews” is the single most-cited dual-tool loop in dev communities, because the reviewer is not grading its own homework.

Recipe 2: Parallel-by-story split

1. 1

   Split the backlog by task shape

   Assign exploratory or cross-cutting stories (a refactor, a bug with unknown cause) to Claude Code, and well-specified, mechanical stories (a new endpoint matching an existing pattern, a batch of test coverage) to Codex.
2. 2

   One worktree per story

   Give every story its own git worktree and branch so the two agents never share a working directory. This is the same isolation rule as any multi-agent setup, covered in depth in our multi-agent coding workflow guide, applied across vendors.
3. 3

   Merge through normal PR review

   Each story lands as its own PR. Because the scopes were disjoint and the directories isolated, the merges are ordinary, no special dual-tool ceremony required.

Recipe 3: Cross-review

1. 1

   One tool writes the change

   Whichever agent fits the task implements it on a branch, as usual.
2. 2

   The other tool reviews the diff

   Before you look at the PR, the other CLI reads the diff cold and writes up concerns: logic errors, missed edge cases, convention violations. Different model families have different blind spots, which is the whole point.
3. 3

   You review last, with the critique in hand

   You read the diff alongside the cross-review notes. In practice this converts your review from a cold read into a verification pass, faster, and consistently sharper on the places one model waved through.

The tax of running both tools is context duplication: Claude Code reads CLAUDE.md, Codex reads AGENTS.md. If the two drift, your agents operate on different versions of the project's rules, and the drift shows up as inconsistent code, not as an error message.

Three rules keep it cheap:

1. 1

   One source of truth

   Pick one file as canonical, most teams pick AGENTS.md since it is the vendor-neutral convention, and make the other either a synced copy or a one-line pointer to it. Never edit both independently.
2. 2

   Keep the shared task file out of the context files

   CLAUDE.md/AGENTS.md hold stable conventions (stack, commands, style, boundaries). The task file (task.md) holds the current unit of work. Mixing them means every task pollutes every future session's context.
3. 3

   Review context files like code

   When a convention changes, the context-file update goes in the same PR. Stale context is the silent killer of dual-tool setups, each agent confidently follows a rule you deleted a month ago.

Starting from zero? Our free AGENTS.md / CLAUDE.md generator produces a solid pair from a few questions.

The recipes above work. What wears people down is the operations around them. Two CLIs means two sets of sessions, and with parallel-by-story you quickly have N terminals: three Claude Code sessions, two Codex sessions, each in its own worktree, each at a different stage of done.

This is the same wall people hit scaling a single tool past a couple of sessions, we cover that trajectory in managing multiple Claude Code sessions, except dual-tool setups hit it sooner because nothing, not even vendor tooling, spans both CLIs.

AIDEN is a macOS desktop app built for exactly this setup. It does not replace Claude Code or Codex, it orchestrates the CLIs you already have installed, on your keys and subscriptions, local-first, from a single kanban board.

The shared-task-file contract is built in too: AIDEN's spec gate means every story gets a written, approved spec before either CLI starts coding, the same contract task.md provides, with an enforced approval step. It is free for one project, so you can put your current dual-tool workflow on a board this afternoon and see whether the operational overhead disappears.