Claudex Loop: Stop Letting Claude Grade Its Own Work
Claudex Loop: Stop Letting Claude Grade Its Own Work
You cannot trust Claude to grade its own work. That's the single biggest flaw in how most people build with AI right now, and it's the exact problem Claudex Loop solves. Instead of letting one model plan, execute, AND grade itself, you bring in a second model — Codex — to review both the plan and the code and tell you, plainly, what's good, what's broken, and why.
I built this skill because every AI model has the same blind spot: it looks at its own work way too favorably. When I ask Claude how good the plan it just wrote is, the answer is always some version of "this thing is awesome." Of course it is. It wrote it. That's not a second opinion — it's a model grading its own homework. Here's exactly how Claudex Loop works under the hood, and what it caught when I used it to rebuild a real app.
Why Can't Claude Review Its Own Plan?
Every single AI model out there rates its own output too high. This isn't a Claude problem specifically — it's true across the board. The model that wrote the plan is the worst possible judge of whether the plan is good, because it's already committed to the decisions baked into it.
That's why you need a system where a second, independent model looks at what the first one built and gives a real verdict: thumbs up, thumbs down, and the reasoning behind it. Not a rubber stamp. An actual critic with different training, different biases, and no ego investment in the plan.
Claudex Loop is that system. You invoke it before you add a feature or when you're kicking off a brand-new greenfield project. The core idea: whatever the first model comes up with — a plan or an implementation — you don't move forward on the big stuff until the second model has looked at it and signed off.
If you used the earlier version of this skill, it was called grill me codex. The two big upgrades in Claudex Loop are a much deeper interrogation phase and far tighter Codex integration during the actual build, so you get a second pair of eyes on the code itself — not just the plan.
What Are the Four Phases of Claudex Loop?
The skill breaks into four phases. Each one exists to close a specific gap where a single model would otherwise cut corners.
Phase 0 — Reconnaissance
First, Claude scouts. It goes out on the web to check whether the answers you need actually exist before it assumes anything. You get the option to invoke deep research — the built-in dynamic workflow — if you want to go really deep on what you're getting back.
One practical note: I have deep research pinned to Opus in this skill. If you run deep research on a lighter model, it'll spin up a swarm of sub-agents that can chew through your usage fast. Pinning it to Opus off the bat keeps that predictable.
Phase 1 — Interrogation
Think of this as plan mode on steroids. Before Claude writes a single line of plan, it interrogates you to get on the same page. It produces an assumptions ledger — a list of everything it assumes you want for the project — and you either confirm it or start branching down different paths.
After the ledger comes the load-bearing tier: the questions that actually change the shape of the build. Every question comes with a recommendation, so if you have no idea, you can go with the recommended answer. But here's my real advice — don't be an accept monkey. If you don't understand why Claude is asking something, there's an option to have it explain further. Use it. Asking Claude to keep explaining until you actually get it is the only way you'll get good at this instead of just hitting "recommended" over and over.
After the load-bearing questions come cosmetic decisions — stuff that doesn't change base functionality. Those get listed out like the assumptions ledger so you can accept them all at once or tweak individual items and move on quickly.
Phase 2 — Review (bringing in the second model)
This is where Codex enters. Claude writes the standard plan.md based on everything you discussed and researched. Then that plan gets sent to Codex, running GPT-5.6, which reviews it in a read-only sandbox and returns a verdict: approved, or revise X, Y, and Z.
Codex sends its revisions back to Claude Code. Claude looks at them, decides what it agrees and disagrees with, and sends its changes back. This loop continues up to five rounds or until they reach an approved verdict. Five is a hard wall on purpose — so you never get stuck in an endless loop burning tokens forever. You can change that number in the skill if you want.
Phase 3 — Build
Once Claude and Codex agree on a plan, you move to the build. And Claudex Loop doesn't force Claude to be the builder. You can have Codex build instead, and whichever model builds, the other one reviews the actual code before anything moves forward. In some cases — say you're bringing in asset generation like GPT Image — it'll even suggest a tandem build where Codex handles a specific portion.
The build review loop is capped at two rounds by default, down from the five in the plan review. I knocked it down because I never felt like I needed more, but that's another knob you can tune. You could even swap Codex out for a local model here if that's how you want to run it.
What Happened When I Rebuilt Calendly With It?
For the demo, I used Claudex Loop to rebuild Calendly — the scheduling app where you send someone a link, they see your availability, pick a time, and it auto-creates a Zoom or Google Meet. Plenty of people pay monthly for it. I figured I'd just build my own, tied to my Google Calendar with Google Meet, and save the subscription. The result is an app I called openbook.
I kicked it off with a stream-of-consciousness prompt: recreate Calendly, all the major features, use Google Meet, tie it to my calendar. Phase 0 asked whether I wanted a standard web search or full deep research — I chose deep, and it showed me the proposed research prompt and the exact questions it was chasing: Google Calendar and Meet scheduling, domain pitfalls, and the general stack. I approved it and let it run.
Then the interrogation phase built the assumptions ledger, walked me through load-bearing questions (which Google account the real calendar lives on — I went with personal Gmail), and listed the cosmetic decisions. Standard stuff.
The plan review actually deadlocked — and that was the point
Then came the Codex review. Claude wrote plan.md, Codex tore into it, and here's where it got interesting: round one surfaced 27 issues, and after five full rounds they still hadn't reached an approved verdict. I'd literally never had it hit the wall before. So I was glad it happened live.
At five rounds with a few minor issues left, the skill gave me options: stop and keep it as-is, accept the deadlock state, or extend the rounds. I extended it. By round seven, Claude and Codex finally reached an approved verdict — the issue count dropping every single round from 27 down to zero. That's the whole value proposition: the hard stop protects you, but you're never trapped by it.
Some of what Codex flagged during that planning phase:
- A double-booking constraint that could not compile — a bug that would've shipped straight into the schema
- An OAuth connect flow with problems in how it handled the Google auth handshake
- A concurrency hole where two reschedules of the same booking could both succeed
These are edge cases, sure. But they're exactly the edge cases that would've quietly broken the app in production.
The build review caught a second wave
After the plan was approved, Claude built openbook. Then a completely fresh Codex session spun up — new context window, hadn't read the plan — and reviewed the code against the actual spec: what got built versus what was supposed to be built. It came back with 23 findings. 19 were accepted and fixed. 4 were rejected.
What that fresh set of eyes caught:
- The time grid drifted after every meeting — bookings slowly desyncing from reality
- The management token was sitting in plain text — a real security problem
- Events blocked the wrong hours on the calendar
And the app itself worked. I booked a slot on the demo — picked a date and 10 a.m., dropped in a name and email, hit confirm — and the confirmation email landed with a join link, with the event showing up on my actual Google Calendar.
Why Does a Second Model Save You Time and Money?
Here's the honest version: if I'd just relied on Claude alone, I probably would've gotten to something that worked eventually — after a bunch of iterations, broken features, and bookings that exist in the database and nowhere else.
The difference is where you catch the problems. With Codex in the room from the start, most of these issues got caught in the planning phase — before a single token was spent building the wrong thing. You're not burning tokens on a flawed build and then burning more tokens fixing it after the fact. You catch it up front, test it, and review it before anything hits production.
That's the entire argument for Claudex Loop. A second model with no stake in the plan is worth more than one model that thinks everything it does is great.
Frequently Asked Questions
What is Claudex Loop?
Claudex Loop is a Claude Code skill that stops Claude from grading its own work by bringing in Codex (running GPT-5.6) as an independent reviewer. It runs in four phases — reconnaissance, interrogation, plan review, and build — and won't let you move forward on big decisions until a second model signs off on the plan and the code.
How is Claudex Loop different from grill me codex?
Claudex Loop is the upgraded version of the earlier grill me codex skill. The two main changes are a deeper interrogation phase with a more thorough line of questioning, and much tighter Codex integration during the build phase, so the second model reviews the actual code — not just the plan.
How many rounds does the review loop run?
The plan review loop is capped at five rounds by default, and the build review loop at two. Both are hard walls to keep you from burning tokens in an endless loop, but you can extend the rounds when they deadlock — in my Calendly demo, I extended the plan review to seven rounds to reach an approved verdict — and you can change the caps directly in the skill.
Do I have to use Claude as the builder?
No. In the build phase you can have Claude build while Codex reviews, or flip it so Codex builds and Claude reviews. For certain projects it'll even suggest a tandem build. Whichever model builds, the other one reviews the code before you move forward.
When should I use Claudex Loop?
Use it before adding a significant feature or when starting a brand-new greenfield project — anytime the cost of a bad plan is high. It's overkill for tiny one-off edits, but for anything where a flawed plan means broken features and wasted tokens, having a second model catch problems in the planning phase pays for itself.
If you want to go deeper into building with Claude Code, join the free Chase AI community for templates, prompts, and live breakdowns. And if you're serious about building with AI, check out the paid community, Chase AI+, for hands-on guidance on how to make money with AI.
