Context-Independent Review
An agent is a bad reviewer of code it just wrote — not because of what it knows, but because of what it has already committed to. The source's diagnosis is about authorship, not capability: "agents are often really bad at editing code or improving code they've just written… because they wrote it, so they just think, 'okay, that's fantastic, that's fine.'" The fix is cheap and structural: don't ask the writing agent to review; spawn sub-agents whose context window never contained the authoring. Same model, same prompt quality — but the reviewer arrives at the diff without the trajectory of decisions that produced it, and so has nothing to defend.
This names a third independence axis, distinct from the two already in the vault. Authority-Independent Verification buys independence along rank (no node is exempt because it is senior). Cross-Model Independence buys it along provider lineage (a checker from the same model shares the author's blind spots). This page buys it along context: the reviewer is the same model and the same lineage, but has not seen — and therefore is not anchored by — the authoring history. The three are orthogonal and stack; context independence is the cheapest and the weakest.
The boundary matters, because the cheapness is seductive. A fresh window removes authorship anchoring; it does nothing about model blind spots. A same-model reviewer with a clean context will still fail to see the class of error its training cannot represent — it just won't be additionally motivated to bless it. So the honest reading is: context independence is a real, near-free improvement over self-review, and not a substitute for a genuinely uncorrelated checker. The source claims fresh-context sub-agents do "a much better job"; the vault should hold that as better-than-self-review, not as verification solved.
In the source's flow the reviewer is also given what to check
against, which is what stops it being theater:
/code-review runs on two axes — the diff against the
original spec (catching things the tickets left unspecified or the agent
forgot) and the diff against the repo's own standards docs, falling back
to Fowler's code smells where a repo documents none. On screen the
implement skill runs typecheck, test, and build, then announces:
"I'll pin the fixed point and gather the diff, then spawn the two
review sub-agents in parallel."
Claims
- An agent cannot review its own work well because it authored it: having produced the code, it reads it as already correct. principle — durable, and about commitment rather than skill. The mechanism is that the authoring trajectory is in the context, so the review is conditioned on the reasoning that produced the very thing under review. Note the vault holds a stronger neighbouring claim — see Cross-Model Independence — that same-model review is an echo chamber no prompt can fix; these name different failures and the tension is worth keeping visible.
- Buy reviewer independence with a fresh context window: spawn review sub-agents that never saw the authoring. best practice — context: any write-then-check stage on one model; nearly free (a sub-agent spawn) and it composes with the other independence axes. It buys freedom from authorship anchoring only — it does not decorrelate the reviewer's blind spots from the author's, so on load-bearing work it is a floor, not a ceiling.
- Context independence, rank independence, and lineage independence are three separate axes and they stack. principle — durable: each removes a different correlation between checker and checked, so buying one does not buy the others. A fleet can be perfectly fresh-context and still be an echo chamber; it can be cross-vendor and still let the author grade itself.
- Give the independent reviewer a written standard to check against — the spec it should have implemented, plus the repo's documented conventions — or the fresh context has nothing to be independent about. best practice — context: a pipeline where a spec already exists as the handoff artifact; the review is a diff-against-intent, which is exactly what a reviewer with no memory of the intent needs supplied. Where a repo documents no standards, the source falls back on Fowler's named smells (Leading Words).
- A final spec-vs-diff pass catches what per-ticket implementation misses — the agent forgetting items or the tickets being unspecified. best practice — context: work sliced across several sessions, where no single window ever held the whole job; the value comes precisely from the slicing this repairs, so single-session work needs it less.
- The general principle beneath this page: you cannot unknow something, but you can start a mind that has never seen it — fresh eyes on demand, for the first time in history. principle — durable, and a genuine widening. A second, independent source (Nate B Jones) reaches the same structural fix from a premise that has nothing to do with code or with agents: "you've read your own product page a thousand times. You'll never see it the way a stranger does." That reframes this page's mechanism — contamination is a property of having been exposed, so the only remedy is a reader who wasn't, and the novelty of the agent era is that such a reader is now instantiable on demand rather than hired. It also supplies a pre-AI lineage this page lacked (peer review works because the reviewer didn't write the paper; banks don't let the payment-enterer approve it; "the auditor who also kept the books isn't a worse auditor, he's just not an auditor at all"), which is the strongest available argument that this is durable structure rather than a quirk of current models. See Team-Forming Constraints, where the same source makes it one of only two reasons to form an agent team at all.
Related
- Cross-Model Independence — the sibling axis and the sharper claim: independence bought along provider lineage, because blind spots are properties of the model. That page holds that no prompt or persona fixes same-model review; this page reports a same-model, fresh-context reviewer doing "a much better job." Both can hold — they name different failures (blind spots vs. authorship anchoring) — but a reader should not take a clean window as having bought what a different vendor buys.
- Authority-Independent Verification — the rank axis; no node exempt from checking. Orthogonal to this one: fresh context says who has seen what, rank says who is above review.
- Context Smart Zone — the other
reason to start a stage on a clean window; there the motive is full
reasoning strength, here it is freedom from prior commitment. The same
/clearbuys both. - Step Isolation — the same hide-what-would-bias-you move, applied within a skill rather than across a write/review boundary.
- Evidence-Gated Completion — independence says who checks; evidence gating says what the check must produce. A fresh-context reviewer with no evidence requirement is still theater.
- LLM-as-Judge — the reviewer is a model judging work; the fresh window is one cheap way to keep the judge from judging itself.
- Spec-Driven Development — supplies the standard the independent reviewer checks against; the spec is the pivot that makes the whole flow reviewable by an agent that wasn't there.
- Agent Task Graph — the builder/validator pair is this pattern given a scheduler.
- Leading Words — the fallback standard when a repo documents none: Fowler's named smells, which the model's priors already carry.
- Team-Forming Constraints — the general form: separation of concerns is one of only two limits that justify a multi-agent team, and "you cannot unknow something" is the principle this page instantiates for code. That page carries the pre-AI lineage (audit, peer review, segregation of duties).
- Distillate: The whole flow, end-to-end: the smart zone is the unit of work
- Distillate: 1.6M agents registered for OpenClaw and did NOTHING. — widens the page beyond code and beyond authorship anchoring: the principle is that exposure contaminates any reviewer of any artifact, and "fresh eyes on demand" is what agents newly make possible.