# williams-adlc-2-two-human-gates-2026-06-12

## Veille

Second installment of Chris Williams's ADLC series: it unrolls the cycle that follows from the "first law" — eight phases (P0 Triage → P7 Distill), a deterministic gate between each pair, and exactly two mandatory human moments (spec approval at P1, behavioral acceptance at P6). Key principle: an LLM→LLM handoff without a deterministic checkpoint multiplies error rates; and a "barbell" cost distribution (heavy at both ends, light in the middle) that inverts agile economics.

## Titre Article

Two Human Gates and Everything Between Is Machine-Checked

## Date

2026-06-12

## URL

https://www.voodootikigod.com/adlc-2-two-human-gates

## Keywords

ADLC, eight-phase agentic cycle, deterministic gates, two human gates, triage, interrogate, decompose, rails, build, prosecute, integrate, distill, LLM handoff, error compounding, barbell distribution, barbell spend, inverted agile economics, two-strike regeneration, model tier, frozen acceptance criteria, context engineering, useful context window

## Authors

Chris Williams (@voodootikigod)

## Ton

Profile: process-architecture exposition (practitioner "we/you" perspective, methodical English register), high technical level, targeting engineering leads deploying agents at scale. The tone is that of a reasoned specification: each phase is introduced by what it defends against (tied to the F1–F8 failure modes of the previous installment), its deterministic exit gate, and its optional human gate. Authority rests on systemic coherence — the cycle "falls out" logically from the rule set in the first installment — and on operational precision (named gates: Cold-Start Test, RED gate, Green gate, Zero-Findings gate). Structurally dense style, backed by a flow diagram (P0→P7 with Approved/Redo loops), the barbell economic metaphor to justify where to spend tokens, and an explicit posture of delegated machine trust between the only two human gates.

## Pense-betes

- **Compounding principle**: "an LLM→LLM handoff without a deterministic checkpoint multiplies error rates." Between any two phases there must be a deterministic gate (compiler, test suite, validator) that resets the accumulation of probabilistic error to zero.
- **Eight phases**: P0 Triage (route by risk and blast radius, not complexity — trivial work short-circuits the cycle); P1 Interrogate (an agent interrogates stakeholders *after* reading the codebase; output: a spec whose acceptance criteria name their verification method; **Human Gate 1: spec approval**); P2 Decompose (cut into atomic tickets executable by fresh agents, explicit contracts at boundaries; gate: a Cold-Start Test by a cheap model catches gaps); P3 Rail (tests, type stubs, contracts written from the spec in isolation, then **frozen** — the builder cannot modify them; gate: tests fail RED for the right reasons, stubs typecheck); P4 Build (one agent per ticket, mid-tier models by default, two-strike regeneration, no personas); P5 Prosecute (fresh agents chartered to refute; up to two consecutive passes finding nothing); P6 Integrate (**Human Gate 2: behavioral acceptance**); P7 Distill (simplify + mine lessons).
- **The two human gates**: spec intent (P1) and behavioral verification (P6). Everything in between is machine-gated. At P6: the human checks conformance summaries, test diffs, runtime behavior, and hotspots — not the full diffs. The question: "Is this what I meant, *running*?"
- **Barbell distribution**: invest heavily in tokens at both ends (planning and review), light in the middle (execution). Inverts agile economics, where "misbuilding is what's expensive."
- **Model tier**: "model tier is a function of the cost of detecting an error, not of task prestige."
- **Explicitly rejected norms**: full-diff human review (theater beyond 500 lines), "agile-light" planning for agentic work, persona engineering, collaborative multi-agent building, write-time DRY, coverage-percentage gates, token quotas as cost control, mid-task model failover.
- **Every rejection traces to a failure mode** documented in the first installment: adopting a ritual requires justifying it explicitly against a proven default.

## RésuméDe400mots

In this second installment, Chris Williams turns the ADLC's "first law" into a concrete cycle: eight phases, a deterministic gate between each pair, and exactly two mandatory human moments. The governing principle is that a direct LLM-to-LLM handoff, without a deterministic checkpoint, multiplies error rates — each probabilistic component wired to another compounds the error. The gates (compilers, test suites, validators) reset that accumulation to zero.

The cycle opens at P0 (Triage): route work by risk and blast radius, not complexity; trivial work short-circuits the full cycle, substantial work goes through all eight phases. P1 (Interrogate) is the highest-leverage phase: an agent interrogates stakeholders *after* consulting the codebase, which prevents generic assumptions from filling gaps in the spec. Its output is a specification where every acceptance criterion names its verification method. This is where Human Gate 1 sits — spec approval, the point of maximum human value.

P2 (Decompose) defends against context rot by splitting the spec into atomic tickets executable by fresh agents, with explicit contracts at the boundaries. P3 (Rail) writes tests, type stubs, and contracts from the spec in isolation, then freezes them — the builder cannot modify them. P4 (Build) launches one agent per ticket on mid-tier models by default, with two-strike regeneration (kill a stalling agent and restart clean) and no personas — capability comes from context, tools, and charter. P5 (Prosecute) deploys fresh agents chartered to refute, with the burden of proof resting on reproducibility, up to two consecutive passes finding nothing. P6 (Integrate) opens Human Gate 2 — behavioral acceptance: the human checks spec conformance, test diffs, runtime behavior, and hotspots — not the full diffs. The question is "is this what I meant, running?" Finally, P7 (Distill) simplifies and mines recurring lessons into lint rules, templates, and skills.

Williams insists on a "barbell" spend distribution: heavy at both ends (planning, proving), light in the middle (executing). This inverts the classic agile economics where "misbuilding is what's expensive." He explicitly rejects full-diff review (theater beyond 500 lines), personas, write-time DRY, and coverage-percentage gates — each rejection traced to a specific documented failure mode.

## GrapheDeConnaissance

- Chris Williams —publie→ Two Human Gates and Everything Between Is Machine-Checked (DOCUMENT, 0.97)
- ADLC —fait_partie_de→ cycle agentique en huit phases (METHODOLOGIE, 0.95)
- Chris Williams —affirme_que→ un handoff LLM→LLM sans checkpoint déterministe multiplie les taux d'erreur (AFFIRMATION, 0.95)
- gates déterministes —réduit→ compounding d'erreur entre phases probabilistes (CONCEPT, 0.93)
- phase Interrogate —permet→ specs dont les critères nomment leur méthode de vérification (CONCEPT, 0.9)
- phase Decompose —réduit→ context rot (CONCEPT, 0.9)
- phase Rail —utilise→ tests et stubs gelés que le builder ne peut modifier (CONCEPT, 0.92)
- phase Build —utilise→ modèles mid-tier par défaut (TECHNOLOGIE, 0.88)
- deux portes humaines —s_applique_à→ intention de spec (P1) et vérification comportementale (P6) (CONCEPT, 0.93)
- distribution en haltère —s_oppose_à→ économie agile traditionnelle (CONCEPT, 0.88)
- Chris Williams —affirme_que→ le tier de modèle dépend du coût de détection d'une erreur, pas du prestige de la tâche (CITATION, 0.92)
- ADLC —s_oppose_à→ revue humaine de diff complet au-delà de 500 lignes (CONCEPT, 0.9)
- chaque rejet de norme —est_basé_sur→ un mode de défaillance documenté des modèles (CONCEPT, 0.88)
- phase Build —utilise→ two-strike regeneration (METHODOLOGIE, 0.87)

---
Canonical: https://www.thekb.eu/en/fiches/williams-adlc-2-two-human-gates-2026-06-12/