## Definition **Verifier independence** is the property that the agent verifying a piece of work has no exposure to the reasoning that produced it. The same intelligence that wrote the code can verify it — *if it's reading the code cold, against an independent contract*. ## Why It Works 1. **No shared bias.** The builder's intermediate reasoning would bias the verifier toward the same blind spots. 2. **Forces re-derivation.** The verifier must reconstruct understanding from artifacts (diff + spec), not from the conversation that produced them. 3. **Asymmetric prompting.** The builder's prompt is *"make this work"*; the verifier's is *"find where this fails."* Different prompts bias toward different outputs. ## Engineering for Independence Several axes, in increasing strength: - **Different reasoning trace.** Always run the verifier as a *fresh* sub-agent invocation, not a continuation. - **Different inputs.** Verifier gets only diff + spec, not the conversation that produced them. - **Different model family.** Sonnet builder, Opus verifier. - **Different tools.** Verifier can run tests; builder might not have. ## Cheapest Move The "fresh sub-agent" axis. It costs nothing extra over running a sub-agent at all — but it eliminates the most common source of false-positive `PASS` verdicts: the verifier echoing the builder's confidence. ## What Without a Contract Without a spec, the verifier has nothing to verify against; it falls back to taste — which is what produced the code in the first place. **Specs + independence** is the pair that earns its keep. ## Related - [[Builder-Critic Pattern]] - [[Sequential Pipeline]] - [[Adversarial Agent]] - [[Spec-Driven Development]]