No AI Should Grade Its Own Homework - The 4-Model Loop I Build Software With

A practical multi-model software loop where Claude orchestrates, ChatGPT builds, Gemini reviews, Claude re-checks, and the human approves at three gates.

I stopped writing my own code. Claude architects it, ChatGPT builds it, Gemini and Claude review it, and I approve three times.

That's the whole loop. Four models, one human, three buttons. Copy it.

The four seats

Claude - the orchestrator. Takes my idea, writes the spec, runs the loop, and keeps every model pointed the same direction.

ChatGPT - the builder. Writes the code against the spec. Nothing else.

Gemini - the first reviewer. Grades the build cold, from scratch, with no memory of how it got made.

Claude - the final reviewer. Re-checks what Gemini flagged and reruns every test itself before anything moves.

Me - the human. I approve at three points: start it, ship today's work, merge. That's it.

Why each model gets the seat it gets

This isn't four models for the sake of a bigger number. Each seat plays to a different strength, and the seams between them are the point.

The orchestrator has to hold the whole system in its head: the spec, the standard, the history of what's been built. That's Claude's job because I've spent months teaching it my standards, and it keeps the other models from wandering.

The builder should not be the same model that set the standard. If one model writes the rules and the code, it grades its own taste. So ChatGPT builds against a spec it didn't write.

The reviewers are two different architectures on purpose. Gemini and Claude fail in different places. Gemini catches things Claude glosses over, and the reverse is just as true. Two models that share a brain share the same blind spots. Two that don't, don't.

The rule that makes it work: no model grades its own homework

The model that built it doesn't get to call it good. And a reviewer can't quietly rewrite the test to turn a failing score into a passing one. A hard rule blocks that move.

Grade the work against the spec, or send it back. Those are the only two options.

That one rule is doing more work than any single model in the loop.

What the three gates actually are

The gates are where I stay the expert in the room, and they're cheaper than they sound.

Gate 1 is the plan. Before anything gets built, I approve what we're building and why. A wrong plan is the most expensive mistake in the whole loop, so I kill it first.

Gate 2 is the daily slice. Each session, I approve what gets built now and in what order - usually a few seconds of reading.

Gate 3 is the merge. Nothing ships until I say so.

Between those three buttons, the models run alone. Three approvals a day beats hovering over every step, and it beats the alternative most people are living with: an AI that runs unsupervised until it quietly does something dumb.

I learned the homework rule the hard way

My first full run used one model in every seat. It shipped fast - a rough idea to merged, tested code in about 45 minutes.

What it built was a router: the thing that reads whatever I drop into my system - an idea, a bug, a half-formed request - and decides which step should handle it and whether it's a quick fix or a whole project.

Then the review step caught something that's changing how I wire this. The build scored 9 out of 10 on my test set. It had misread "build this system end to end" as a code-only job, when the right answer spans both the code and the reusable pieces.

And here's the part that matters: it could have faked the 10 by editing the test to match the code. The hard rule stopped it. It logged the miss instead, and I closed it the next day at 13 out of 13.

A builder and its grader sharing one brain is a weakness. That run is exactly why I'm splitting the seats across models now.

What I actually design now

The work isn't the code anymore. It's the loop.

I write the spec: what "done" looks like as a checklist a machine can grade. I write the rubric the reviewers score against. I write the hard rules that can't be broken: no faking a test, no secrets in the code, nothing ships without the evidence attached.

Then I let the four models run inside those rails.

Most people bolt AI onto a process they never actually mapped, then wonder why it breaks. The loop only works because the standard is written down before a single model touches the task.

Why this 10x's my output

I stopped doing the work. I design the loop the work runs through.

One person can only build so much by hand. But designing end-to-end agent loops - four models passing work down an assembly line, me holding the three gates that actually matter - means I can run more of those in a day than I used to build in a week.

The bottleneck was never the code. It was me being the only one allowed to touch it.

Steal the four seats and the one rule. Point your models at a small task and watch it move down the line. Then tell me: which seat would you assign differently?