AI Reflection, Done Right — Without the Doom Loop

Having a model read its own output and fix it — "reflection" — is the shallow version of letting AI check its own work, and it does not hold up in production. The reliable version is a discipline with four parts, and the last one is where almost everyone goes wrong: get it wrong and you get a doom loop — an AI that revises forever, fails forever, and converges on nothing. Here is the shape:

text   ┌──────────────┐   armed with the fast checks as TOOLS —
   │   PRODUCER    │   it self-corrects while it builds
   └──────┬───────┘
          │  one COMPLETE artifact
          ▼
   ┌──────────────┐   run EVERY code gate; collect EVERY rejection
   │  CODE GATES   │── fail ─▶ back to the producer with the FULL list
   └──────┬───────┘           (never stop at the first failure)
          │  clean
          ▼
   ┌──────────────┐   the LLM judge — only what code can't check:
   │    JUDGE      │   taste, "is it a real place," the aha.
   └──────────────┘   a SAFETY NET, expected to pass ~9 times in 10

Push everything you can into code

A check that can be a deterministic gate should be one — instant, free of tokens, never wrong. A model's judgment is the most expensive thing in the system; spend it only on what code genuinely can't decide (the same instinct as making the answer itself checkable). So the first pass a piece of work faces is all code — and the producer is armed with those same fast checks as tools, because a cheap check it can run while it builds kills the problem before it's baked in.

Hand back every rejection at once

When the gates do reject, they run all of them and return the complete list — never stopping at the first failure. A producer that gets told "fix this," fixes it, comes back, and is told the next thing, and the next, is already halfway into the doom loop. One pass, the whole list, one revision.

The judge checks only what code can't

Only once the work is code-clean does a model judge see it, and only for the things no assertion can capture: is it a real place, does it surprise, does a label mean what it should. It is a safety net, expected to pass about nine times in ten.

The part almost everyone gets wrong: one shared contract

Everything above is table stakes. This is the part that quietly breaks pipelines: the producer and the judge must read the same contract. The producer's job is build to this; the judge's job is check against this. It has to be one document used twice — never two documents that happen to agree. In one stage it isn't even a metaphor: the shared contract is a literal string — the studio calls it the EMBODIMENT BAR — injected verbatim into both the producer's prompt and the judge's, so the two cannot drift.

Because drift opens a gap, and the gap has two shapes:

• The mild one: the producer makes something the judge never checks. A silent hole.
• The ruinous one: the judge checks something the producer was never told to make. Now every run fails for a reason the producer couldn't have anticipated. It revises blindly, fails again, and the judge slowly teaches it a contract it never agreed to — round after round, burning tokens, converging on nothing.

This isn't hypothetical. An audit of this studio's own pipeline once found every part connected correctly but the instructions contradicting — one step telling a producer to do exactly what another step forbade. The data flowed; the contracts didn't agree. That is the doom loop's native habitat: two contracts, drifting.

The tell is simple: the judge starts failing a lot. A judge is a safety net; if it is catching most of what comes through, the net isn't the problem — the thing above it is.

The one rule

Which is why one rule gets repeated more than any other, and it sounds backwards until you've lived the loop: when something is wrong, fix the producer first — never the gates, never the judge. The producer is the root cause of every failure; the judge only confirms it. Tighten the judge to catch a new bug and you've taught the producer nothing. Tighten the producer's contract, and the judge goes quiet again — the way a safety net is supposed to.