# klaassen-thinkroom-compounding-knowledge-lifecycle-2026-07-02

## Veille

Agent guide (Thinkroom, Kieran Klaassen's platform) documenting the **Compounding Knowledge Lifecycle** of the compound-engineering-plugin (Every): how a lesson learned once "keeps paying off" — captured, stored, retrieved, and kept true. Describes the anatomy of a *learning* (`docs/solutions/`), its capture via `/ce-compound`, the memory map (durable vs ephemeral), *grep-first* retrieval (learnings-researcher) wired into 5 skills at decision points, and the three counterforces that keep memory from lying. Directly relevant: it is the doctrine behind this repo's `docs/solutions/` convention. Domain: compound engineering, agentic knowledge management, skills.

## Titre Article

The Compounding Knowledge Lifecycle — Agent Guide

## Date

2026-07-02

## URL

https://thinkroom.kieranklaassen.com/d/Yxr8tfwAVV

## Keywords

Compound engineering, compounding knowledge lifecycle, learning, solution doc, docs/solutions, /ce-compound, learnings-researcher, pattern doc, durable vs ephemeral memory, grep-first, frontmatter, present evidence wins, coherence neighborhood, /ce-compound-refresh, failure class retirement, CONCEPTS.md, repo-profile cache

## Authors

Kieran Klaassen (Thinkroom / Every — compound-engineering-plugin) ; document « Agent Guide » généré (byline « Claude Code / Anthropic »)

## Ton

**Profile**: a reference technical guide with an agentic purpose ("Agent Guide"), third person, dense analytical register, structured into 8 numbered sections + a glossary. High technical level, addressed as much to agents as to engineers practicing compound engineering.

**Style**: explanatory and systematic, each section describing one phase of the cycle (premise → capture → storage → detection → refresh → complete loop → why it compounds). Constant use of **tables** (the role of each frontmatter field, consumers of memory, failure modes avoided) and **diagram descriptions**. A deliberate and "earned" **extended financial metaphor**: *learning = principal*, *a retrieval that changes a decision = interest payment*, *pattern doc = reinvestment*, the corpus (35 docs) = *balance sheet*. Doctrine formulas: *"knowledge you'd mourn goes in git; knowledge you can re-derive goes in /tmp,"* *"present evidence wins,"* *"a confidently wrong memory is worse than none,"* *"not that documents accumulate, but that failure classes get retired,"* *"no empty hands."* Authority through self-demonstration: the guide treats itself as a living corpus (a census of 35 learnings, the `/ce-explain` feature shipped "yesterday," the real incident #714). **Target audience**: designers of agentic systems and skills, practitioners of compound engineering.

## Pense-betes

- **Compound engineering's founding bet**: *"each unit of work should make the next unit easier."* **Code** improves the *product*, not the *process*; what **compounds** is **knowledge** — every solved problem, named concept, and documented convention in a form **retrievable at the exact moment future work needs it**.
- **The real bottleneck = retrieval**, not writing. Postmortems "rot in wikis because nobody re-reads them." This system **closes the loop** by making retrieval **automatic** across 5 skills, not a matter of voluntary discipline.
- **A *learning* (solution doc)** = 1 markdown file = 1 solved problem, under `docs/solutions/<category>/`. **The entire frontmatter serves *search*, not narrative**: `title` (grep target #1), `tags` (synonym surface — grep `tags:.*(menu|routing|handoff)` without opening a file), `module`/`component` ("is this my area?"), `problem_type` (the routing switch), `applies_when` (a 3-line self-selection test), `severity` (ranking when several match), `date` (obsolescence signal).
- **`problem_type` = 2 tracks**: **bug-track** (what broke: `runtime_error`, `test_failure`, `performance_issue`, `security_issue`…) and **knowledge-track** (what was *decided/discovered*: `architecture_pattern`, `design_pattern`, `tooling_decision`, `convention`, `workflow_issue`, `best_practice`…). *"A system that only retains bugs forgets the essential part of what a team learns."* Living census: **35 learnings, 6 categories, skill-design in the lead (20)**.
- **Pattern doc** = one notch up: generalized from *several* learnings → **more leverage, more risk if it goes stale**. None promoted here yet (`docs/solutions/patterns/critical-patterns.md` = a slot waiting to be filled).
- **Capture = `/ce-compound`**, core discipline = **timing**: document **while context is still fresh** (same session as the fix, while the failed attempts and the "ah, THAT's why" are still there). A week later → it degrades into a summary.
- **Mechanics**: fan-out of subagents (**context analyzer** = category/name/frontmatter, **solution extractor** = prose body problem/investigation/solution/prevention, **related-docs finder** = dedup check); **only the orchestrator writes ONE doc**, subagents never touch tracked files. Other entry points: `/ce-debug` (offers a compound after root-cause), `/ce-pov` ("compound it" → `tooling_decision` in headless mode), **lightweight mode** (small lessons, skips the dedup check).
- **"The life of a learning"** (canonical example): issue **#714** (the agent stops after the menu) → root cause (per-option routing in a reference file that wasn't loaded) → fix + `/ce-compound` → learning `post-menu-routing-belongs-inline.md` → **regression test** + **doctrine in AGENTS.md** ("Inline the Trigger, Not the Content"). **One incident, 4 durable artifacts.** *"Compounding" = failure classes get retired*, not just documents piling up.
- **Memory map, axis = durability.** **DURABLE (git)**: `docs/solutions/` (the 35 learnings), `CONCEPTS.md` (vocabulary/glossary, never specs), `STRATEGY.md` (direction/tracks), `docs/plans/` + `brainstorms/` (the **WHY**). **EPHEMERAL (derived)**: **repo-profile cache** (re-derived 1×/commit, shared by 9 skills, never a source of truth — deleting it loses nothing). Rule: *knowledge you'd mourn → git; re-derivable → /tmp*. **Plans are never edited after execution** → they still explain the *why* months later.
- **Detection: nothing pushes knowledge toward you** (no digest, no "read the wiki"). **5 skills pull it** at decision time, via a shared **learnings-researcher** protocol, **grep-first** (memory is designed to be *searched* without being *read*). Funnel: 35 docs → parallel frontmatter greps → a handful of candidates (~30-line frontmatter) → full-read of the winners → **5 distilled findings** into the caller's context.
- **Consumers**: `/ce-plan` (learnings → constraints & KTDs), `/ce-brainstorm` (frames the scope), **`/ce-code-review`** (always-on reviewer: **followed / violated** verdict against the actual diff — *"the sharpest tooth"; a violation = a `file:line` finding, not a suggestion*), `/ce-ideate` (prunes past dead ends), `/ce-debug` (surfaces known root causes).
- **2 trust rules**: (1) **Present evidence wins** — if a learning contradicts the current code, the conflict is **flagged** instead of failing it (a *confidently wrong* memory is worse than none); (2) **Date is signal** — every learning carries its date to weigh whether the world has moved on.
- **Refresh — "memory that only ever grows eventually lies."** 3 counterforces at different tempos: **read time** (present evidence wins, free); **write time** (when adding/editing a `CONCEPTS.md` entry, inspect its **coherence neighborhood** — the referenced sibling terms — and correct drift *for which there is evidence*; bounded, never a full audit run on a hunch); **on demand** (`/ce-compound-refresh`, a deliberate sweep, **NOT a default follow-up**, only runs when there is a reason, takes a **scope hint** — `/ce-compound-refresh payments` — because a full-corpus refresh is almost never the right spend).
- **The complete loop via `/ce-explain`** (skill shipped "yesterday," everything actually happened): brainstorm pulls the repo-profile from cache; planning surfaces **5 learnings** (3 *must-apply*: inline menu routing [legacy of #714], `$ARGUMENTS` portability, `SKILL_DIR` anchor); implementation creates its **mirrored regression test**; review audits the diff against **8 learnings** (all followed) and **rejects a reviewer-proposed fix** that would have reintroduced the original failure mode (*"memory didn't just inform the work, it defended it"*); compound vocabulary (*Explainer*, *Check-in* → `CONCEPTS.md`); leftover → **issue #1057** → future **learning #36**. *"No step required anyone to remember to consult the memory."*
- **Why it compounds (financial metaphor)**: learning = **principal**, every retrieval that changes a decision = **interest payment**, pattern doc = **reinvestment**. Failure modes avoided: wiki rot, stale guidance that kills new work, uncurated accumulation, invisible memory, decay, silos (a single `docs/solutions/` serves 9 skills).
- **Direct link to this repo**: the `docs/solutions/` convention (frontmatter `module`/`tags`/`problem_type`) documented in the veille repo's `CLAUDE.md` is exactly this system; the `compound-engineering:*` skills (`ce-compound`, `ce-plan`, `ce-code-review`, `ce-compound-refresh`…) are installed here. **A natural candidate for firm-wide promotion** (a capitalization pattern).

## RésuméDe400mots

This agent guide from Thinkroom (Kieran Klaassen's platform) describes the **Compounding Knowledge Lifecycle** of the compound-engineering-plugin: the mechanism by which "a lesson learned once keeps paying off." Compound engineering's founding bet: *every unit of work should make the next one easier*. Yet code improves the product, not the process; what **compounds** is **knowledge** — provided it is documented in a form that is **retrievable at the exact moment it is needed**. The real bottleneck, then, is not writing (postmortems "rot in wikis") but **retrieval**, made **automatic** here across five skills rather than left to discipline.

The unit is the **learning**: a markdown file, one solved problem, under `docs/solutions/<category>/`, whose **entire frontmatter serves search** (`title`, `tags`, `module`, `problem_type`, `applies_when`, `severity`, `date`). `problem_type` splits into **bug-track** (what broke) and **knowledge-track** (what was decided/discovered) — because "a system that only retains bugs forgets the essential." Living corpus: 35 learnings, skill-design in the lead. Above it, the **pattern doc** generalizes several learnings (more leverage, more risk if it goes stale).

**Capture** happens via `/ce-compound`, whose discipline is **timing** (documenting while context is still fresh), with a fan-out of subagents (analyzer, extractor, dedup-check) while only the orchestrator writes a single doc. The canonical example — incident #714 becoming a fix + learning + test + doctrine — shows that "compounding" means **retiring failure classes**, not stacking up documents.

The **memory map** contrasts the durable (git: `docs/solutions/`, `CONCEPTS.md`, `STRATEGY.md`, plans/brainstorms = the WHY) with the ephemeral (re-derivable repo-profile cache). **Detection** pushes nothing: five skills **pull** at decision time via the grep-first **learnings-researcher** (35 docs → frontmatter greps → candidates → full-read → 5 findings). `/ce-code-review` is "the sharpest tooth": a violation becomes a `file:line` finding. Two trust rules protect it: **present evidence wins** and **date is signal**.

Finally, **refresh** keeps memory from lying via three counterforces (read time, write time via *coherence neighborhood*, on-demand scoped `/ce-compound-refresh`). The loop is illustrated end-to-end by the delivery of `/ce-explain`. Financial metaphor: learning = principal, retrieval = interest, pattern doc = reinvestment — a system where new work "arrives immune to past mistakes."

## GrapheDeConnaissance

- Compound engineering —affirme_que→ "chaque unité de travail doit rendre la suivante plus facile" (AFFIRMATION, 0.95)
- Compounding Knowledge Lifecycle —est_basé_sur→ docs/solutions/ (DOCUMENT, 0.94)
- Learning —fait_partie_de→ docs/solutions/ (DOCUMENT, 0.95)
- Learning —est_basé_sur→ frontmatter conçu pour la recherche (grep-first) (CONCEPT, 0.92)
- ce:compound —permet→ Learning (CONCEPT, 0.93)
- ce:compound —utilise→ subagents (context analyzer, solution extractor, related-docs finder) (METHODOLOGIE, 0.9)
- learnings-researcher —permet→ récupération grep-first aux points de décision (5 skills) (CONCEPT, 0.93)
- /ce-code-review —utilise→ learnings pour un verdict followed/violated contre le diff (CONCEPT, 0.92)
- /ce-plan —utilise→ learnings comme contraintes et KTDs (CONCEPT, 0.9)
- Pattern doc —est_basé_sur→ plusieurs learnings généralisées (DOCUMENT, 0.9)
- repo-profile cache —est_instance_de→ connaissance éphémère re-dérivable (CONCEPT, 0.9)
- Compounding Knowledge Lifecycle —recommande→ "present evidence wins" (signaler le conflit si le code contredit) (AFFIRMATION, 0.92)
- /ce-compound-refresh —résout→ obsolescence de la mémoire (balayage scopé, non par défaut) (CONCEPT, 0.9)
- Compounding Knowledge Lifecycle —affirme_que→ "compounding = retirer des classes de défaillance, pas empiler des docs" (AFFIRMATION, 0.9)
- Compounding Knowledge Lifecycle —résout→ wiki rot (postmortems non relus) (CONCEPT, 0.9)
- Kieran Klaassen —a_créé→ Thinkroom (TECHNOLOGIE, 0.85)

---
Canonical: https://www.thekb.eu/en/fiches/klaassen-thinkroom-compounding-knowledge-lifecycle-2026-07-02/