# williams-adlc-6-lifecycle-gets-cheaper-2026-06-12

## Veille

Sixth installment on the ADLC: Williams describes the P7 "Distill" phase as the component that drives cost down on every run. Two halves: post-merge simplification (deduce after the code exists, not before — "deduplicating before the code exists is speculative") and lesson mining (a "lesson foundry" turns recurring findings into lint rules, skills, and new interrogation questions). Each lesson is paid for once, then demoted from expensive probabilistic detection to free deterministic prevention. The right unit of account is "cost per merged, verified change," and "flat cost is failure."

## Titre Article

The Lifecycle That Gets Cheaper Every Run

## Date

2026-06-12

## URL

https://www.voodootikigod.com/adlc-6-lifecycle-gets-cheaper

## Keywords

ADLC, Distill phase, P7, declining cost, post-merge simplification, observable deduplication, lesson foundry, lesson mining, lint rule, skill rot, model ratchet, ratcheting, cost per merged change, unit of account, flat cost is failure, capitalization, deterministic prevention, compounding

## Authors

Chris Williams (@voodootikigod)

## Ton

Profile: economic-technical essay (practitioner perspective in English, analytical and prescriptive register), high technical level, targeting leads and program managers overseeing agent usage cost. The tone is one of systematic capitalization: Williams treats knowledge produced by the cycle as an asset to bank, and cost as a trajectory to measure over time rather than a snapshot. Authority rests on a sharp, counterintuitive thesis — "flat cost is failure" — and on choosing the right unit of account (cost per merged, verified change), which requalifies prosecution spend as investment. Diagnostically structured style: two halves of Distill, four broken-loop indicators, foundry (lesson foundry) and ratchet (model ratchet) metaphors to convey the irreversibility of compounded gain.

## Pense-betes

- **Thesis**: without an intentional mechanism for capturing lessons, agents offer **no** cumulative advantage — they restart from zero every cycle. The P7 Distill phase is the missing component that drives cost down run after run.
- **Distill, half 1 — Simplification**: architectural review should happen **after** the merge, not before. "Deduplicating before the code exists is speculative"; post-merge deduplication targets observable patterns. Tests guarantee behavior preservation during cleanup, letting less capable models participate without risk.
- **Distill, half 2 — Mining (lesson foundry)**: turns recurring findings into permanent defenses — deterministic problems become lint rules with tests; contextual patterns feed a skill-mining pipeline; spec gaps trigger new interrogation questions (P1).
- **Lesson economics**: each lesson is paid for **once**, then demoted from expensive probabilistic detection to free deterministic prevention.
- **Skill rot**: stale artifacts deliver misinformation with authority. Countermeasure: weekly verification passes that extract checkable claims (commands, paths, versions) and flag their freshness.
- **Model ratchet**: re-audit existing code with frontier models after a release, to catch what earlier versions had missed — a ratchet that never slips backward.
- **Right unit of account**: not "tokens-per-developer" but **"cost per merged, verified change."** This framing requalifies spend: prosecution-phase costs are investments, not waste.
- **Four indicators of a broken loop**: spend concentrated in Build phase → missing skills; rising prosecution spend → lessons never repatriated; hitting the iteration cap → weak specs; flat cost trajectory → system failure.
- **Provocative thesis**: "flat cost is failure." A working system shows a measurably **declining** cost per change as skills accumulate and lint layers thicken.

## RésuméDe400mots

The sixth installment answers the question that decides the economic viability of agents: why should an agentic cycle cost less on every run? Williams's answer is that it doesn't, spontaneously. Without a deliberate mechanism for capturing and institutionalizing lessons, agents offer no cumulative advantage — they restart from zero knowledge every cycle. The component that changes this is the P7 phase, Distill.

Distill has two halves. The first is simplification. Counterintuitively, architectural review and deduplication should happen after the merge, not before. Deduplicating before the code exists is speculative; deduplicating after targets patterns that are actually observable. Tests, already in place, guarantee behavior preservation during this cleanup, which lets less capable — and therefore cheaper — models participate without risk.

The second half is lesson mining, organized as a "lesson foundry." This foundry turns recurring findings into permanent defenses: deterministic problems become lint rules paired with tests; contextual patterns feed a skill-mining pipeline; specification gaps trigger new questions in the interrogation phase. The underlying economics are decisive: each lesson is paid for once, then demoted from expensive probabilistic detection to free deterministic prevention.

Williams identifies two enemies of compounded gain. First, skill rot: stale artifacts deliver misinformation with authority; the countermeasure is a weekly verification pass that extracts checkable claims (commands, paths, versions) and flags their freshness. Second, the model ratchet: after each release, re-audit existing code with frontier models to catch what earlier versions had missed — a ratchet that allows no backward slip.

The installment culminates in the right unit of account. Rather than tracking tokens per developer, successful programs measure cost per merged, verified change. This reframing transforms how spend is read: prosecution-phase costs are not waste but investment. Four indicators reveal a broken loop: spend concentrated in the Build phase signals missing skills; increasingly expensive prosecution signals lessons that were never repatriated; repeated hits against the iteration cap signal weak specs; and a flat cost trajectory signals system failure. The thesis holds in four words: "flat cost is failure." A healthy system sees its cost per change measurably decline as skills accumulate and lint layers thicken.

## GrapheDeConnaissance

- Chris Williams —publie→ The Lifecycle That Gets Cheaper Every Run (DOCUMENT, 0.97)
- phase Distill —réduit→ coût par changement run après run (CONCEPT, 0.92)
- phase Distill —fait_partie_de→ cycle agentique en huit phases (METHODOLOGIE, 0.9)
- simplification post-merge —surpasse→ déduplication avant écriture du code (METHODOLOGIE, 0.89)
- Chris Williams —affirme_que→ dédupliquer avant que le code existe est spéculatif (CITATION, 0.91)
- lesson foundry —permet→ conversion des findings récurrents en règles de lint, skills et questions (CONCEPT, 0.9)
- règle de lint —remplace→ détection probabiliste coûteuse par prévention déterministe (CONCEPT, 0.88)
- skill rot —réduit→ fiabilité des artefacts de connaissance (CONCEPT, 0.88)
- model ratchet —permet→ ré-audit du code par modèles frontier après release (CONCEPT, 0.88)
- cost per merged change —surpasse→ tokens-per-developer comme unité de compte (CONCEPT, 0.89)
- Chris Williams —affirme_que→ un coût plat est un échec (« flat cost is failure ») (CITATION, 0.92)
- dépense de prosecution —est_instance_de→ investissement plutôt que gaspillage (CONCEPT, 0.86)

---
Canonical: https://www.thekb.eu/en/fiches/williams-adlc-6-lifecycle-gets-cheaper-2026-06-12/