An agent builds something — a piece of logic, a migration, a paragraph of copy. It finishes, says it's done, and it looks right. You ask the same agent, "Are you sure this is correct?" It re-reads its own work and says yes. You ship. It breaks on exactly the case the agent never thought to question — and there's the trap: the reason it never questioned that case is the same reason it couldn't catch it on review. It was grading its own homework, with the very pencil that made the mistake.
01The author can't see its own blind spot
An agent checking its own output brings back the exact assumptions that produced it. If it misread the requirement the first time, it misreads it the same way on review — confidently. A single model has correlated failure modes: ask it twice and you get the same miss twice, dressed up as a second opinion. "Check your work" feels like a safeguard, but a reviewer that shares the builder's mind isn't a second opinion at all. It's the first opinion, repeated louder.
✕ Same agent checks itself
✓ A different agent checks it
02A second agent, with a different mind
Add a second agent whose role is not to build, but to disagree — to review, to audit, to try to break what the first made. The leverage multiplies when it's a different model or vendor: different training, different habits, different blind spots. Where two builders of the same make miss the same things, two minds of different makes miss different things — so between them, far less slips through. The second agent isn't a spare pair of hands; it's the pair of eyes the first one structurally cannot have.
Produces the work — and carries the assumptions that made it. It is not asked to judge its own output.
A different model, whose only job is to find what's wrong. It reads, raises findings, and never merges its opinion as fact.
Triage the findings — not all are real — decide what's true, and hold the gate: nothing merges until the other set of eyes has passed it.
03Split by function, not by area
This is a different cut from splitting one big task across many agents for speed. That split is by area — each agent its own non-overlapping patch of work, so two never touch the same spot. This split is by function: one produces, the other judges the same thing. The reviewer reads only and raises findings; the builder fixes and never approves its own fix. The single rule that makes the pairing work: whoever wrote it doesn't get to sign off on it. The moment the author is also the approver, you're back to grading homework — and the blind spot wins.
04When the second pair of eyes earns its keep
It isn't free. A reviewer costs a round of coordination, and most throwaway work doesn't need one. It earns its keep when correctness matters more than raw speed, when the work is hard to eyeball, and especially when something that "looked right" has burned you before. That last one is the tell: if you keep shipping things that passed your glance and broke anyway, you don't need a faster builder — you need an independent checker the builder can't talk over.
05Putting it to work
- Give the reviewer a review-only role and the standard to check against — the spec, the requirement, what good looks like. A reviewer with no yardstick only nitpicks.
- Make it a different model where you can. Same model reviewing same model shares the very blind spot you're trying to escape.
- Frame it adversarially: ask it to find what's wrong or try to break this — not "is this good?" The second framing fishes for approval; the first fishes for problems.
- Triage the findings yourself. The reviewer surfaces; you decide what's real and what's noise.
- Loop the roles: the builder patches, the reviewer re-checks, and nothing merges until the other set of eyes has passed it.
A team of two with split roles catches a whole class of errors a lone agent is blind to — cheaply, before they reach anyone else. The cost is a little coordination; the payoff is that you stop shipping confident-but-wrong work. It comes back to the thread under all of this: an agent can't see its own blind spots. A second perspective isn't something the first will grow on its own — it's something you add.