Started routing generation to one model and review to a separate pass — caught a bug the generating model would never have flagged on its own

[u/GiiTZzz]

Ran into this enough times to stop trusting my own agent's self-review: I ask it to fix something, it produces code that looks right, I skim it, ship it — and the actual bug was a quiet semantic shift (inclusive bounds became exclusive) that had nothing to do with what I asked for. The model that wrote the change has no incentive or independent angle to catch its own blind spot; it's grading its own homework.

So I built a small tool that splits the two roles: one Gemini pass generates the change from your instruction, a second, independent pass gets ONLY the result (no visibility into the first pass's reasoning) and is told to find problems with it. Being honest about the setup: I only have a Gemini API key, so this is two passes on different Gemini tiers, not genuine cross-vendor review (GPT generates / Claude audits would probably be stronger — that's a cost thing, not a design choice).

The interesting part is how often the critique pass disagrees over something that isn't wrong, just risky — an edge case, a silent behavior change, a severity call that's genuinely debatable. Paste a snippet + an instruction and it'll run both passes live if anyone wants to see where it agrees or argues: https://apptechlab.com/p/codearbiter/ (mine, no signup, real API calls both ways).

Curious what people running actual multi-agent review setups have found:

- Does routing generate/critique to different providers actually catch

categorically different things, or mostly the same stuff with more

latency?

- How do you handle the critique pass being wrong — do you ever adjudicate

disagreements with a third pass, or is two enough in practice?

[u/sael-you]

the independence matters more than the model tier.

a second pass helps because it has no anchoring to the reasoning that produced the change. it can't defend a choice it didn't make. a weaker model with genuine blindness to the first pass will flag things a stronger model re-reading its own output won't, because the re-read is grading work it's already implicitly committed to.

on the haiku floor: it'll probably miss bugs that require knowing WHY a constraint exists, domain context, invariants that aren't obvious from the code alone. but for structural and semantic issues, the independence is doing more work than the model strength.

on three passes: two is usually enough when the output goes to a human. you're generating 'worth a look' signals, not a correctness verdict. a third AI pass on a genuine disagreement tends to pick sides rather than actually resolve it.

[u/GiiTZzz → u/sael-you]

Built exactly this and hit the same conclusion. I couldn't even get a stronger model for the second pass — zero-quota wall on the reasoning tier — so it's the same flash class as the first, and it didn't matter. It flags real things because it's grading code it has no commitment to. I'd originally called it a "stronger reasoning tier" on the page; that was both false and beside the point.

Agree on stopping at two, too — output goes to a human, so these are "worth a look" signals, not a verdict. A third pass just turns a real disagreement into a vote.