# williams-adlc-4-prosecution-not-code-review-2026-06-12

## Veille

Fourth installment in the ADLC series: Williams reframes code review as adversarial "prosecution" rather than collaborative evaluation. Charter agents to refute ("find what's wrong"), deploy single-lens reviewers with fresh contexts (correctness, security, contract compliance, spec alignment, test quality), act only on verified findings (reproduced by a failing test), and loop until two consecutive passes yield zero findings. Measure calibration by planting known bugs, mutation-testing style. Exit gate: zero open findings, two dry passes, green tests, empty test diff.

## Titre Article

Prosecution, Not Code Review

## Date

2026-06-12

## URL

https://www.voodootikigod.com/adlc-4-prosecution-not-code-review

## Keywords

ADLC, prosecution, adversarial review, refutation vs evaluation, sycophancy, findings hallucination, fifteen-finding stopping bias, single-lens reviewers, fresh contexts, verified findings, phantom churn, loop-until-dry, review calibration, planted bugs, recall per category, false positives, exit gate, mutation testing

## Authors

Chris Williams (@voodootikigod)

## Ton

Profile: methodological advocacy (practitioner perspective in English, argumentative and incisive register), high technical level, target audience quality leads and engineers building agentic review stacks. The tone is one of conceptual requalification: the judicial metaphor (prosecution, burden of proof, verified findings) structures the entire piece and shifts the expectation from a review that "gives an opinion" to one that "demonstrates a reproducible flaw." Authority rests on explicit grounding in failure modes (F2 sycophancy, F4 hallucination, F6 findings-count bias) and on a measurement requirement rarely applied — "almost every team trusts its review stack blindly." Style structured around numbered principles, a concrete example of a planted bug (a truthiness guard that skips verification), and closure with a strict, verifiable exit gate.

## Pense-betes

- **Central reframe**: code review is not a collaborative evaluation but an adversarial **prosecution**. When asked for a conventional review, models exhibit sycophancy, hallucinated findings, and an artificial stopping point around fifteen problems.
- **1. Refutation rather than evaluation**: instead of asking for feedback, charter the agent to "find what's wrong" or explain how the project would fail. This redirects sycophancy bias (F2) toward identifying flaws rather than seeking approval.
- **2. Single-lens prosecution**: deploy parallel reviewers with fresh contexts, each examining **a single** dimension — correctness, security, contract compliance, spec alignment, or test quality. Distributing concerns avoids the context saturation that dilutes judgment.
- **3. Verified findings only**: before builders act, require independent verification — reproduce the bug via a failing test, trace the code paths, or generate the triggering input. "Unverified findings" (F4) cause real churn for phantom problems.
- **4. Loop-until-dry**: re-run the prosecution with fresh contexts until **two consecutive passes** yield no verified findings. This sampling-based approach defeats F6 (the training prior that stops around 10-20 findings regardless of the actual number of defects).
- **Calibration measurement**: almost every team trusts its review stack blindly. The solution mirrors mutation testing: plant known bugs (mechanical mutations + subtle LLM-written bugs), run the entire prosecution stack, measure recall per category and the false-positive rate.
- **Example of a planted bug**: add a truthiness guard that skips verification when a field is absent — defensive-looking, but introducing a security rot.
- **Exit gate**: the review passes when (1) zero open verified findings, (2) two consecutive dry passes, (3) green test suites, (4) **empty** test diff (proof that builders did not modify their own gates).

## RésuméDe400mots

The fourth installment reinvents code review for the agentic world. The starting observation: when models are asked to perform a conventional review, they disappoint in predictable ways. Sycophancy (F2) pushes them to approve rather than critique; hallucination (F4) leads them to invent problems; and a training bias (F6) makes them stop around fifteen findings, regardless of the actual density of defects. Williams draws a reframe from this: what's needed is not an evaluation, but a prosecution — an adversarial accusation.

Four principles structure this prosecution. First, refutation rather than evaluation: instead of asking for feedback, the agent is chartered to "find what's wrong" or explain how the project would fail. Sycophancy bias, thus reversed, works in your favor. Next, single-lens prosecution: rather than a single omniscient reviewer, parallel agents with fresh contexts are deployed, each dedicated to a single dimension — correctness, security, contract compliance, alignment with the spec, test quality. Distributing concerns avoids the context saturation that dilutes judgment across competing priorities.

The third principle is verified findings only. Before a builder acts on a critique, it must be independently proven: reproducing the bug via a failing test, tracing the code path, or producing the triggering input. Without this, hallucinated findings generate real code churn for problems that don't exist. The fourth principle is loop-until-dry: the prosecution is re-run with fresh contexts until two consecutive passes yield no verified findings at all. This repeated sampling defeats F6's artificial stopping point.

Williams then flags a near-universal blind spot: almost every team trusts its review stack blindly, without ever measuring its actual detection capability. His solution mirrors mutation testing applied to reviewers: plant known bugs — mechanical mutations plus subtle bugs written by an LLM — run the entire prosecution stack, then measure recall per category and the false-positive rate. Example of a planted bug: a truthiness guard that skips verification when a field is absent, defensive-looking but introducing a security flaw.

Finally, the exit gate is strict and fully verifiable: zero open verified findings, two consecutive dry passes, green test suites, and an empty test diff — this last condition proving that builders did not modify their own gates to pass.

## GrapheDeConnaissance

- Chris Williams —publie→ Prosecution, Not Code Review (DOCUMENT, 0.97)
- prosecution —s_oppose_à→ revue de code collaborative (METHODOLOGIE, 0.92)
- prosecution —réduit→ sycophancie du reviewer (CONCEPT, 0.91)
- reviewers mono-lentille —réduit→ saturation de contexte qui dilue le jugement (CONCEPT, 0.9)
- findings vérifiés —réduit→ churn de code sur des problèmes hallucinés (CONCEPT, 0.91)
- loop-until-dry —réduit→ biais d'arrêt autour de 10-20 findings (CONCEPT, 0.9)
- calibration de revue —s_inspire_de→ mutation testing (METHODOLOGIE, 0.9)
- calibration de revue —mesure→ recall par catégorie et taux de faux positifs de la stack (MESURE, 0.88)
- Chris Williams —affirme_que→ presque toutes les équipes font confiance à leur stack de revue à l'aveugle (AFFIRMATION, 0.89)
- bugs plantés —permet→ mesure de la capacité réelle de détection des reviewers (CONCEPT, 0.88)
- phase Prosecute —fait_partie_de→ cycle agentique en huit phases (METHODOLOGIE, 0.9)
- gate de sortie de prosecution —utilise→ diff de tests vide comme preuve de non-altération (CONCEPT, 0.89)

---
Canonical: https://www.thekb.eu/en/fiches/williams-adlc-4-prosecution-not-code-review-2026-06-12/