The most productive thing I did with AI coding this spring was stop asking which model is better and start asking which model belongs in which seat. Claude Code on Opus is my builder: it plans ambitiously, writes confidently, and — the flip side of the same trait — ships its own mistakes with total conviction. Codex on GPT-5.5 is my skeptic: token-stingy, surgical, structurally suspicious of whatever it's shown. The official Codex plugin for Claude Code puts both in one terminal, and the handoff is now fast enough that I actually do the second-model review instead of perpetually intending to.
I resisted installing it, for the reason most engineers would: a competitor's tool inside my primary tool smells like a janky bridge that breaks every release. It isn't. The plugin is published and maintained by OpenAI itself, and the moment that converted me was watching Claude plan a multi-table Laravel migration on my own platform — clean plan, confident narration — and miss a foreign-key constraint that the cross-model review pass caught before implementation started. Not because Claude is weak. Because Claude was in build mode, and nobody reviews their own work well. That's not a model problem; it's the same reason human teams separate author and reviewer.
Install and the Actual Command Surface
Setup is marketplace-style, four lines inside Claude Code:
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup
The plugin shells out to the Codex CLI (npm install -g @openai/codex if you don't have it; Node 18.18+), and /codex:setup verifies auth. You need a ChatGPT subscription or an OpenAI API key — and notably, the free ChatGPT tier qualifies, so you can trial the whole workflow before committing to a paid second plan.
The commands you'll actually use:
/codex:review— read-only Codex review of uncommitted changes or a branch comparison/codex:adversarial-review— a steerable challenge review that questions design decisions, not just diffs/codex:rescue— delegate a task to Codex: investigate, fix, or continue work/codex:transfer— spin the current Claude session into a persistent Codex thread/codex:status//codex:result//codex:cancel— manage background jobs/codex:setup --enable-review-gate— a Stop hook that has Codex review every Claude turn and block completion when it finds issues
That adversarial-review command deserves a highlight, because when I started running dual-model reviews I was faking it — prompting /codex:review with "act like the hostile engineer who inherits this code in six months." The plugin now ships that posture natively. Use it. Polite reviews return cosmetics; adversarial reviews return the bugs you'd have shipped.
Workflow 1: The Adversarial Planning Loop
The highest-leverage pattern, and the cheapest. Claude drafts the implementation plan — schema, file paths, migration order, contract surfaces. This is Claude's home turf and I let it go long. Then, before a line of implementation exists, the plan goes to Codex for an adversarial pass.
On that Laravel migration, the review flagged the missing foreign key, a soft-delete column present on the parent table but absent on the child, and a unique index that would deadlock under concurrent writes — all inferred from the surrounding schema and controller logic, not from the migration file alone. Claude revised, Codex re-reviewed, done in two rounds.
Two rounds is my hard limit. If a plan needs a third round, the plan is being patched around a wrong decomposition, and the correct move is to scrap it and re-plan from a different angle. This rule has saved me more time than any other part of the workflow.
The economics are the point: plan review burns thousands of tokens; implementation burns hundreds of thousands. Every bug caught at the markdown stage is a bug you never pay to write, debug, and unwind in code. I put the head-to-head model economics in GPT-5.5 vs Opus 4.7 on real builds — the short version is that critique is an order of magnitude cheaper than creation, which is exactly why the skeptic seat costs so little.
Workflow 2: Background Audits While You Build
On existing codebases — my Laravel platform, client apps — the pattern inverts from sequential to parallel. Claude builds in the foreground while /codex:rescue runs audits in the background on whatever subsystem I'm touching: security review on anything handling auth or input, query review on anything hitting write-heavy tables, hygiene review on anything I'll hand to another developer.
Background execution is the unlock. Fire the job, keep building, check /codex:status a few minutes later, read /codex:result when it lands. The number-one productivity killer in agentic coding isn't bad output — it's context-switch tax, the price you pay every time you stop building to review. Backgrounding the review removes the tax entirely.
One practical note: scope your audits. Point Codex at the directory you're working in plus its direct dependencies — the models a controller touches, the migrations those models touch — and skip the rest. Even generous context windows reward focus, and unscoped whole-repo audits return unfocused findings.
Workflow 3: The Pre-Release Gate
Senior engineers ship cleaner code not because they write fewer bugs but because they've built a final-pass habit: read the whole diff as if you'd never seen it. AI workflows skip that step by default because the model just keeps going. The pre-release audit restores it: when a branch is functionally complete, run an adversarial review against the full diff, framed as the on-call engineer who gets paged when this breaks.
The findings cluster into four buckets, reliably: authorization gaps on routes that look read-only but mutate state; information leaks in error paths (validation messages confirming account existence, stack traces naming columns); performance footguns (N+1 queries inside Blade loops, lazy relations that should be eager — I find these in my own Laravel work more often than I'd like to admit); and hygiene rot (comments contradicting code, function names that lie).
For genuinely sensitive branches, flip the review gate on: /codex:setup --enable-review-gate makes Codex review every Claude turn via a Stop hook and block completion until issues are addressed. It's the strictest and most token-expensive mode in the plugin. My rule: on for the final day before a production deploy on sensitive paths, off the moment the deploy lands. Left on permanently, it will chew through a modest OpenAI plan and slow every interaction. Gates are for gating, not for living behind. This layer stacks naturally with the review tooling I already run — the Superpowers-style review loop sits at the same point in the pipeline.
Workflow 4: Flipping the Polarity
Sometimes the seats swap: Claude plans, Codex implements. I reach for this on tasks where the failure mode is subtle correctness rather than architecture — the kind of code that compiles and breaks at runtime. /codex:rescue with an explicit implement-don't-review framing delegates the work as a background job; /codex:result drops the diff back into the Claude session for integration.
The discipline that keeps this honest: never delegate work you can't review yourself. Dual-agent coding works because you're the adjudicator — when the models agree you ship, when they disagree you decide. Delegate something outside your competence and you're back to single-model blind trust, except in the model you know less well. The clean delegation surface is "I understand the problem, I'd spot a wrong answer, I just don't want to spend my morning on the grunt work." That's a much smaller surface than "anything Claude is mediocre at," and staying inside it is the difference between a workflow and a gamble.
A Concrete Test: The URL Shortener
To stress the workflow end to end, I built the classic deceptively-simple project: a Bitly-style shortener with custom slugs, expiration, click analytics, and rate limiting. Claude scaffolded it in one session and it ran on first deploy — auth working, shortening working, dashboard rendering. Done, by any surface measure.
The adversarial audit disagreed. Slug generation used Math.random() with a retry loop that had no backoff — fine until collisions start. Expiration assumed UTC everywhere while the input form accepted local time, so a link expiring "today" could resolve as dead depending on the user's side of midnight. The rate limiter keyed on IP without checking forwarded headers, meaning one proxy IP could exhaust the bucket for everyone behind it. A second, tighter audit on just the expiration feature surfaced cases I hadn't mentally modeled at all: boundary-day midnight behavior and what "expired" means when the click and the check straddle a DST transition.
None of that ships clean from a single model, and honestly most of it survives a single human review too — humans review the code that exists, while adversarial review is structurally good at finding the code that's missing. The audit cost a few dollars. The alternative was a weekend of production patching.
The Plan Math
The obvious objection is that two AI subscriptions doubles the bill. It doesn't, because the seats have asymmetric workloads. My setup: Claude Code on the $100 Anthropic tier as the workhorse — generation is the expensive activity, so that's where the budget goes. Codex on the $20 OpenAI tier for review and occasional delegation — critique consumes a fraction of the tokens. Net change from my previous Claude-only setup: 20 percent. One caught pre-production bug per quarter pays for years of that differential, and in practice it catches more than one. (If you make review-gate mode your default rather than your exception, budget a higher OpenAI tier — that mode is the exception for a reason.)
I've written the fuller side-by-side of the two harnesses in Claude Code and Codex on the same repo and the broader Codex field test. This post is the synthesis of where all that testing landed: not a rivalry, a team of two with you as tech lead. Give the builder ambition, give the skeptic a mandate, keep the adjudication for yourself.
Where teams get this wrong in production is the gate: they leave review-gate mode on across the whole repo, watch latency and the OpenAI bill climb together, and conclude the dual-agent idea doesn't pay. Which gates belong where is a stack-specific question, so send me your setup and I'll tell you which of these four workflows is worth wiring up first.
