Codex Inside Claude Code: Cross-Model Review With codex-plugin-cc

A repository named codex-plugin-cc came out of OpenAI as open source, and its strangest property is the place it runs. That's neither ChatGPT nor OpenAI's Codex app. It plugs into Claude Code, Anthropic's terminal coding agent, and the main feature lets Codex sit in a rival's tool and review what that tool just wrote.

Consider the oddity. A company built a polished, well-maintained plugin whose headline move is giving your code to the competing lab's model for a second look, and the repo has gone past 25,000 stars. One reading says OpenAI just wants more Codex usage, which is partly right. The sharper reading is that OpenAI is wagering in public that no model should mark its own work.

Why a different reviewer helps

The reason has nothing to do with loyalty to a brand. Once a model has written a chunk of code and then reviews it right away, that second pass isn't fresh. The assumptions, the framing and the proposed approach all remain in its context, which makes endorsing the design easier than questioning it. You can't proofread your own prose at 2am for the same reason: your eyes see what you intended to write.

Using another model won't guarantee a better answer. Labs can share training data, coding habits and blind spots, so a different provider isn't automatically an independent one. What you do get is a second set of defaults and failure modes, and a prompt written for reviewing asks it to push back instead of continuing. That mix can expose assumptions the first model never examined. Codex isn't right by default, and Claude isn't wrong by default. The gain comes from the reviewer not having authored the solution. OpenAI pitches it the same way: a more skeptical pass by a different agent, harder to charm into agreement.

None of this is new to software. It's code review. The plugin just makes the reviewer a different mind than the author, automatically, so you don't paste a diff into another window.

A thin wrapper by design

The most admirable design choice is how little it claims for itself. codex-plugin-cc has no runtime of its own and no web portal to visit. Where Codex is already signed in on your machine, the plugin asks for no separate login. Calls go through the codex binary you already installed, so your sign-in, repo checkout, environment variables and ~/.codex/config.toml all carry over. It's a wrapper, and it behaves like one.

Review is only half the story. The same wrapper hands whole tasks to Codex, rescues stalled ones, and moves a live session over to Codex when you'd rather continue there. So it's a general Claude-to-Codex bridge, and not a single-purpose lint button.

The commands that matter

After installation, Claude Code gains a set of slash commands. Two of them do most of the work.

/codex:review is the plain, read-only option. It examines whatever you haven't committed, or compares your branch with main when you pass --base main, and it reports bugs, gaps in tests and edge cases without modifying a single file.

/codex:adversarial-review is where the plugin earns its place. An ordinary review asks if the code works; the adversarial kind asks if this was the right thing to build. You can aim it by adding a focus after the command, for example asking it to question your caching and retry approach. It goes looking for buried assumptions, rollback failures and race conditions, the problems that pass every test and then page you in the middle of the night.

Two others are handy. /codex:rescue passes an entire job to Codex once Claude stalls, for instance "investigate why the tests started failing." /codex:transfer takes the chat you've been having in Claude Code and continues it as a live Codex session, which saves you from explaining the architecture again. Job control through /codex:status, /codex:result and /codex:cancel rounds things out, because reviewing many files takes time and a locked-up terminal is no fun.

The review gate, handle with care

One optional feature deserves a closer look before you enable it, since the documentation attaches a warning to it. Turn it on with /codex:setup --enable-review-gate. The plugin then registers a Stop hook, so each time you try to finish a Claude Code turn, a targeted Codex review runs first. A problem found by Codex blocks the stop, and Claude must resolve it before you can proceed. In effect, review becomes a gate that blocks shipping, with no manual step.

Great in theory, and an easy way to waste money in practice. Say Claude and Codex disagree over how some detail should be implemented. They can bounce the change back and forth, one patching, the other objecting, and each round bills tokens on both accounts. The README itself warns that the gate may trigger an extended Claude/Codex loop and burn through usage limits fast. Keep it disabled until a specific high-stakes change comes along that you're happy to supervise, enable it for that session alone, then turn it off.

Where this is heading

Step back from individual commands and the direction becomes clear. People spent a while treating Claude Code and Codex as rival camps. The plugin's answer is to stop choosing. Claude stays the lead agent that holds the plan and the context over a long session. Whenever a task stalls, a review is due, or a design feels shaky, Codex gets it, and the result returns to the same workflow. One loop then contains an author and a critic with different defaults, which gives a second chance at whatever either one overlooks. Base models begin to look like swappable parts, and the orchestration around them becomes the real product.

Hardware is part of the story as well. OpenAI and Work Louder are planning to unveil Codex Micro on July 15, 2026, pitched as a way to speed up Codex shortcuts you use often. It resembles Work Louder's programmable Creator Micro controller, though nothing is confirmed on price, on the exact controls, or on which Codex actions land on physical keys. Even so, building a dedicated keypad for agent shortcuts suggests the company expects the workflows to turn repetitive enough that people will want buttons. That reads as a long-term bet instead of a gimmick.

Getting a first result

You need Claude Code already installed, plus Node.js 18.18 or later. The shortest route to a real result goes like this:

1. Register the marketplace. Inside Claude Code, enter /plugin marketplace add openai/codex-plugin-cc to make the repo a plugin source.
2. Install the plugin. Run /plugin install codex@openai-codex, then /reload-plugins.
3. Run setup. Run /codex:setup. It checks that Codex is present and signed in. If Codex is missing and npm is available, it can install it, or you can run npm install -g @openai/codex yourself. A first-time user signs in once with !codex login, using a ChatGPT account or an API key. The free ChatGPT tier works, and usage counts against your Codex limits.
4. Make a modest edit in a real repository. Keep it unglamorous: tweak one function and leave the change uncommitted.
5. Run the review. Type /codex:review --background, check progress with /codex:status, and read the findings with /codex:result. Background mode keeps your terminal usable while Codex works.

The first time Codex flags something Claude wrote and Claude then fixes it, you'll understand why this matters more than any benchmark. That one loop is the whole experience.

When you're comfortable, try the real thing. Make a design decision you're unsure about, run /codex:adversarial-review, and name exactly what it should challenge. Point it at the choice that's been bothering you. Here's a full loop with real stakes, starting with a feature Claude builds:

Claude implements a token-refresh flow for authentication.

Then you ask Codex to attack it, and it reports back:

You run:
  /codex:adversarial-review --background challenge token rotation,
  replay protection, concurrent refresh requests, and rollback behaviorCodex comes back with three risks.You ask Claude to verify each finding against the code and the tests,
not to auto-accept all three.

The final step is where the discipline lives. Codex raising a concern settles nothing; it gives you a lead. Return that lead to Claude and have it check against the actual code, then decide yourself. Being the last reviewer to speak earns no extra authority. Another habit pays off too: commit or stash before either agent edits anything. The two review commands only read, but /codex:rescue can attempt a fix, and a clean snapshot gives you something to roll back to.

What it costs

It isn't free, in two ways. Each review and each delegated task spends Codex usage, and adversarial loops spend it faster than you'd expect. On a ChatGPT plan that drains subscription limits, and on an API key it produces billable usage. Either way, watch it before turning this into a habit. The review gate in particular can eat limits or run up charges while you're away mid-session.

Some teams will care about another cost more than money: a second company gets to read your code. Whatever goes through Codex for a review or a delegated job reaches OpenAI's tooling, in addition to what Claude Code already sends Anthropic. With a proprietary repository that puts two vendors in contact with your source, and company policy has to allow both. Settle that question first, before aiming the plugin at anything from work. It outweighs any hung job.

Expect more moving parts too. Two vendors' authentication, two runtimes and the bridge joining them all have to keep working. Handoffs between processes are brittle by nature. Several fixes have landed, some Windows-specific, but recent issue reports still describe hanging reviews, leftover Codex processes and jobs that sit in a "running" state forever. A stuck job will turn up sooner or later, and /codex:cancel is the way out.

It won't make either model smarter, either. Two reviewers beat one, yet if both models share a blind spot they'll miss the same thing, and independent doesn't mean correct. Read the adversarial review as a sharp second pair of eyes, not an oracle. A clean verdict from Codex is evidence, never a guarantee.

Finally, small self-contained scripts don't need it. The payoff grows with the cost of being wrong, so use it on the auth flow, the migration, the money-handling path, and skip it for one-offs.

The question to carry away

The interesting part isn't technical. OpenAI made its model more useful by embedding it in a rival's tool, which only pays off if developers will run several models at once regardless of what any single company wants. They probably will. The one-model workflow, where you choose an assistant and live inside it, is starting to look like what people did before they knew better.

That leaves a different question for your next risky change. Skip asking which model is best and ask who will argue with your first draft. Aim a second model at that change and see what it says you missed. When it finds what no benchmark would, the reason OpenAI shipped a tool that lives in someone else's house becomes obvious. The code is in the openai/codex-plugin-cc repository.