Claudex Loop: have Codex review Claude's code, and the other way around, Quentin IA Marketing

When the AI that wrote your code is also the one reviewing it, it signs off on its own blind spots. Same reasoning, same gaps, and an "all good" that proves nothing.

Claudex Loop starts from one simple rule: whoever builds it never grades it. It's a set of open source skills for Claude Code and Codex (MIT license, more than 3,000 stars on GitHub as of October 18, 2026). Your session writes the plan, the other provider's model challenges it with evidence, then one model builds the code and the other inspects it, in a fresh session.

You put Anthropic and OpenAI up against each other on your project, and you're the referee.

This guide gives you the install, the full loop, the role swap and the settings that matter. Everything is checked against Claude Code 2.1.302 and the repository README as of October 18, 2026.

Claude AI Lab

The Claude AI Lab is my Skool community where I share my Claude systems and the more advanced modules. Access is $67/month.

Join the Lab →

✅What you need

Claude Code installed and signed in. It's the host of the loop when you start from Claude, or the Anthropic-side reviewer when you start from Codex.

Codex CLI installed and signed in. To use GPT-6 Astra, you need Codex CLI 0.153.0 or newer.

Python 3.10 or newer. It runs the shared adapter between the two CLIs. No pip packages, no extra API keys.

Paid access at Anthropic AND at OpenAI. The skill is free, the usage isn't: it puts both of your accounts to work (subscription or credits), exactly as if you used them separately.

The program

Check both CLIs

⌨️ Terminal, one line at a time

🔌Both must report signed in

Anthropic side. claude --version, then claude auth status.

OpenAI side. codex --version, then codex login status.

Python. python3 --version must show 3.10 or higher.

Before you install

If one of these commands fails, fix it first. The full loop needs both CLIs installed and authenticated, otherwise the cross-provider review never starts.

The five commands to copy:

claude --version
claude auth status
codex --version
codex login status
python3 --version

Install Claudex Loop

🔗 github.com/chaseai-yt/claudex-loop

⚙️Two routes, pick yours

In Claude Code, the easiest route: the plugin. Two commands in your session, then /claudex-loop:claudex-loop runs the full loop.

For Codex, or for a manual install. Clone the repository and copy the skills folder into ~/.agents/skills (Codex) and ~/.claude/skills (Claude Code).

Open a new session. Skills are only picked up when a session starts. To update a manual install: git pull, then copy again.

Copy the whole folder

The codex-review and codex-build commands rely on the engine that lives in claudex-loop: copied without it, they don't work. Copy all the skills together.

The plugin, inside Claude Code:

/plugin marketplace add chaseai-yt/claudex-loop
/plugin install claudex-loop@claudex-loop

The manual install, from your terminal (macOS or Linux, the equivalent PowerShell commands are in the repository README):

git clone https://github.com/chaseai-yt/claudex-loop
cd claudex-loop
mkdir -p ~/.agents/skills ~/.claude/skills
cp -R skills/. ~/.agents/skills/
cp -R skills/. ~/.claude/skills/

What the copy installs:

🔁

claudex-loop

The full loop: requirements, plan review, build, final inspection.

🧭

claudex-route

Recommends which model should handle a task, and can run a single handoff. It works on its own, without the loop.

🔍

codex-review

An explicit command to have Codex review a plan.

🛠️

codex-build

An explicit command to have Codex do the build.

Run the loop

🔄 Plan, review, verdict

🧩The four phases

Recon. Your session reads your code and existing docs. On a new project, it lays out its assumptions, each one with a source.

Requirements. It settles with you the decisions that change the outcome, then writes a plan with observable acceptance criteria and a proof command.

Review by the other provider. It reads the plan and the relevant code, returns evidence-backed findings, then rereads every revision. Five rounds at most by default.

Build, then inspect. The chosen model builds from the plan, the proof command runs, and the other provider inspects the final code in a fresh session.

Approval has to be earned

The approval records the plan's path and fingerprint. Edit the plan afterward and the approval is void. And a review request never authorizes the build: you give the green light.

To run the loop, type /claudex-loop in Claude Code after a manual install (/claudex-loop:claudex-loop with the plugin), or $claudex-loop in Codex. Then describe what you want in one sentence. To review a plan that already exists, in three rounds only:

claudex this plan, mode=review, plan=docs/migration.md, rounds=3

The review ends on one of these three verdicts:

✅

APPROVED

The plan is validated, the build can start.

✏️

REVISE

Findings backed by evidence: your session weighs them, fixes the plan, and it goes back for review.

⛔

BLOCKED

Persistent disagreement or rounds used up. It's reported as is, never turned into an approval.

You get two files back: PLAN.md, what gets built, and PLAN-REVIEW-LOG.md, the log of findings, decisions, models used, proof and the uncertainty that remains.

Swap the roles

🔀 The builder setting

👥Who does what, by default

You start from Claude Code. Your Claude session writes the plan, Codex reviews it, Claude builds, and a fresh Codex session inspects.

You start from Codex. Your Codex session writes the plan, Claude reviews it, Codex builds, and a fresh Claude session inspects.

You flip it with builder. builder=codex or builder=claude picks who builds. The inspector follows that choice and is always the other provider.

Watch the fixes

If your session takes over fixes after the inspection, those new edits need another independent inspection. The log keeps track of who wrote and who reviewed each part.

From Claude Code, to have GPT-6 Astra do the build:

claudex this feature, builder=codex, reviewer_model=gpt-6-astra

From Codex, to have Claude Fable 5.1 do the build:

claudex this feature, builder=claude, reviewer_model=claude-fable-5-1

The settings that matter

🎛️ The README controls table

🤖The models

Claude Fable 5.1 and GPT-6 Astra are recommended when they're available on your accounts. Otherwise, each CLI keeps the model you configured for it.

No silent fallback. The requested model and the model actually used are logged separately.

Read-only reviews

Codex reviews run in a read-only sandbox, and Claude reviews only get file reading and search, with no MCP servers. The reviewer challenges, it doesn't touch anything.

The settings to know, all passed in your launch sentence:

🏗️

builder

Who builds: claude or codex. Defaults to the host.

🎯

reviewer_model, builder_model, inspector_model

The model for each role. Defaults to what each CLI is configured with.

🔁

rounds

Plan review rounds, 5 by default.

🩹

MAX_FIX_ROUNDS

Fix attempts during the build, 2 by default.

🔎

MAX_INSPECTION_ROUNDS

Initial inspection plus one reinspection, 2 by default.

📄

mode

full by default, review to start from an existing plan.

🧪

PROOF_CMD

The agreed command that proves the deliverable works, taken from the plan or the repo.

What the loop doesn't do

A clean verdict doesn't prove the model is right, and the README says so itself. Zero findings is a valid result, and a long list of findings isn't a quality score. Read PLAN-REVIEW-LOG.md before you sign off, and keep the decisions in your hands.

The loop doesn't commit or push anything for you either: commits, pushes and publishing follow your own instructions.

Remember

Two models that disagree cost you a few more rounds. One model reviewing itself costs you the bugs it can't see.

What to do now

Install the plugin, open a new session and run /claudex-loop on a small feature. Let the review go all the way to a verdict, try builder=codex on the next task, and read the log before every sign-off.

If you also want to split your daily work across the two subscriptions so you never run out of quota, the full setup is in the two-model stack, Claude Code and Codex.