# klaassen-compound-engineering-definitive-guide-every-2026-02-09

## Veille

Compound engineering reference manual: 7-step agentic loop (Ideate→Brainstorm→Plan→Work→Review→Polish→Compound), 40+ agent plugin, 5-stage adoption scale, 50/50 rule — Kieran Klaassen (Cora / Every) - Every Source Code

## Titre Article

Compound Engineering: The Definitive Guide

## Date

2026-02-09

## URL

https://every.to/source-code/compound-engineering-the-definitive-guide

## Keywords

compound engineering, AI-native philosophy, 7-step loop, inverted complexity, Claude Code, open source plugin, subagents, multi-agent code review, agent-native, 50/50 rule, plans are the new code, 5-stage adoption scale, lessons learned, docs/solutions, CLAUDE.md, harness, vibe coding, /lfg, Cora, Every, SDLC, software development lifecycle, agentic SDLC

## Authors

Kieran Klaassen (avec Claude & GPT crédités co-auteurs du guide complet)

## Ton

**Profile**: Practitioner-founder perspective (product GM), doctrinal manifesto-handbook register, intermediate to advanced level

**Description**: Kieran Klaassen writes in "reference manual" mode — the text explicitly presents itself as *The Definitive Guide* and aims to fix the vocabulary, philosophy, and tooling of a movement already circulated across several earlier Every articles. The tone is assured, almost doctrinal: it states a canonical definition (*"each unit of engineering work should make subsequent units easier—not harder"*) then sets it squarely against the usual fate of codebases that degrade over time (*"after 10 years, teams spend more time fighting their system than building"*). Authority rests on proof by usage — Cora and Every's five products run by single-person teams. The rhetoric proceeds through belief reversals (*"beliefs to unlearn"* / *"beliefs to adopt"*), through striking maxims (*"Plans are the new code,"* *"Ship more value. Type less code."*, *"Taste belongs in systems, not in review."*), and through a highly structured pedagogical apparatus (adoption scale, checklists, code examples). Target audience: developers and technical leaders looking to move from occasional AI use to systematized agentic engineering.

## Pense-betes

- **Canonical definition**: Compound engineering is the approach where *each unit of engineering work makes subsequent units easier, not harder*. It inverts the complexity trajectory: bug fixes eliminate entire categories of future bugs, patterns become tools, the codebase gets easier over time.
- **Main 7-step loop**: **Ideate → Brainstorm → Plan → Work → Review → Polish → Compound → (Repeat)**. Three phases: human decision (what to build?), agent execution (plan/code/test/PR), human judgment (is the output sufficient? did the system learn?). 1. **Ideate** (`/ce-ideate`): ambiguity → prioritized product options (confidence/impact/complexity scoring). 2. **Brainstorm** (`/ce-brainstorm`): fuzzy idea → concrete requirements, saved to `docs/brainstorms/`. 3. **Plan** (`/ce-plan`): 3 parallel research agents (repo, framework-docs, best-practices) + spec-flow-analyzer → structured plan in `docs/plans/`. 4. **Work** (`/ce-work`): isolation (git worktree), step-by-step execution, validations, PR. 5. **Review** (`/ce-code-review`): specialized reviewers in parallel, findings prioritized **P1/P2/P3**. 6. **Polish** (`/ce-polish-beta`): actually clicking through the app, what "feels wrong" (speed, animation, copy, empty states). 7. **Compound** (`/ce-compound`): "the critical step" — capturing the solution in `docs/solutions/` with YAML frontmatter, updating CLAUDE.md, creating agents. *"Would the system catch this automatically next time?"*
- **The plugin** (`EveryInc/compound-engineering-plugin`): **40+ specialized agents**, **30+ slash commands**, **35+ skills**. Review = ~23 reviewers (always-on: correctness, testing, maintainability, project-standards, agent-native, learnings; conditional: security, performance, API contract, migrations, reliability, adversarial; stack-specific: Rails, Python, TypeScript, Swift/iOS, frontend-races). Installable on Claude Code, Cursor, Codex (+ Copilot, Factory Droid, Gemini, etc.).
- **Project tree**: `CLAUDE.md`/`AGENTS.md` (most important file, read every session) + `.compound-engineering/config.local.yaml` + `docs/brainstorms/`, `docs/plans/`, `docs/solutions/` (categorized: performance-issues, security-issues, architecture-patterns, conventions…).
- **`/lfg`**: autonomous development from idea to merged PR (Plan → Work → review+autofix → browser tests → commit/push/PR).
- **50/50 rule (revision of the 80/20)**: 50% of time building features, 50% improving the system (review agents, pattern documentation, test generators). ROI: 1 hour creating a review agent saves 10 hours over the year — *system improvements compound, features don't*.
- **8 beliefs to unlearn**: code must be hand-written / every line manually reviewed / the solution comes from the engineer / code is the primary artifact / first drafts must be good (*"first attempts have a 95% garbage rate"*) / code is self-expression (*"the code is not really yours"*) / typing more means learning more (*"understanding matters more than muscle memory"*) / engineering thinking ≠ product thinking.
- **8 beliefs to adopt**: extract one's *taste* into the system; 50/50 rule; trust the process + safety nets; **agent-native environment** (*"if a developer can see or do something, the agent should too"*); parallelization (the new bottleneck is compute, not human attention); *"Plans are the new code"*; *"engineers are product people now"*; let agents run while you're away.
- **5-stage adoption scale**: 0 manual → 1 chat-assistance → 2 agentic with line-by-line review (most plateau here) → **3 plan-first, PR-level review (key transition: compound engineering starts here)** → 4 idea→PR (1 machine) → 5 parallel cloud execution (multi-feature, multi-device).
- **Agent-native — 4 levels**: (1) basic dev (files, tests, commits); (2) full local (browser, logs, PR); (3) prod visibility (read-only logs, error tracking); (4) full integration (tickets, deployment) → unlocks stage 5.
- **Skip permissions**: `alias cc='claude --dangerously-skip-permissions'`; deliberately scary name; safety nets = git reset, tests, PR review, worktrees. 5-10× flow gain. Never in production or while learning.
- **3 questions without tooling**: *"What was the hardest decision?"* / *"What alternatives did you reject and why?"* / *"What are you least confident about?"*
- **Detailed best practices**: disposable *baby app* to iterate on design; figma-design-sync + design-iterator; codifying design/copy *taste* into skills; structured user research (personas, frontmatter) readable by AI; usage pattern extraction (heavy/struggle/workaround/abandonment); copy = UX (codifying voice); automated product marketing (release notes + Playwright screenshots generated from the plan).
- **Strong veille link**: consolidation text for the philosophy circulated in [[shipper-klaassen-compound-engineering-every-agents-2025-12-11]], [[klaassen-stop-coding-start-planning-every-2025-11-06]], [[klaassen-teach-ai-think-senior-engineer-every-2025-11-07]]; v260 review pipeline [[chow-compound-engineering-v260-review-pipeline-2026-03-31]]; level 5 "Workflows / harness" of taylor-entis-every-eight-levels-ai-adoption-2026-06-02.

## RésuméDe400mots

With *Compound Engineering: The Definitive Guide*, Kieran Klaassen delivers the reference manual for an AI-native engineering philosophy that Every has been promoting since late 2025. The thesis is economic: AI transforms development economics, to the point that Every runs its **five products** (Cora, Spiral, Sparkle, Monologue, Proof) with **single-person teams** — one engineer can "ship like five."

The **canonical definition**: *each unit of engineering work should make subsequent units easier, not harder*. In traditional engineering, every feature injects complexity; after ten years, teams fight their system more than they build. Compound engineering reverses that slope: bug fixes eliminate entire categories of future bugs, patterns become tools, the codebase gets *easier* over time.

The operational core is a **seven-step loop**: **Ideate → Brainstorm → Plan → Work → Review → Polish → Compound**, organized into three phases (human decision, agent execution, human judgment). **Plan** orchestrates three parallel research agents followed by a spec-flow-analyzer; **Review** deploys specialized reviewers (always-on, conditional, stack-specific) producing findings prioritized P1/P2/P3; **Compound** — "the critical step" — captures each solution in `docs/solutions/` with YAML frontmatter and updates `CLAUDE.md`, turning knowledge into a reusable, redistributed asset.

All of this is tooled by an **open source plugin** (`EveryInc/compound-engineering-plugin`): 40+ agents, 30+ slash commands, 35+ skills, installable on Claude Code, Cursor, Codex. The `/lfg` command automates idea→merged PR.

The guide then proceeds by reversing beliefs: **eight to unlearn** (hand-written code, line-by-line review, code as self-expression — *"first attempts have a 95% garbage rate"*) and **eight to adopt** (extracting one's *taste* into the system, the **50/50 rule** — half features, half system improvement —, an **agent-native** environment: *"if a developer can see or do something, the agent should too"*, parallelization, *"Plans are the new code"*).

Adoption follows a **five-stage scale**, from manual writing (0) to parallel cloud execution (5), with compound engineering starting at **stage 3** (plan-first, PR-level review). Klaassen finally details best practices: disposable *baby app* design, skip permissions, codifying *taste* (design, copy), structured user research, usage pattern extraction, automated product marketing. Signature maxims: *"Taste belongs in systems, not in review,"* *"Ship more value. Type less code,"* *"Assign outcomes, not tasks."*

## GrapheDeConnaissance

- Kieran Klaassen —publie→ Compound Engineering: The Definitive Guide (DOCUMENT, 0.98)
- Compound Engineering —affirme_que→ chaque unité de travail rend la suivante plus facile (AFFIRMATION, 0.98)
- Compound Engineering —est_basé_sur→ boucle 7 étapes Ideate-Brainstorm-Plan-Work-Review-Polish-Compound (CONCEPT, 0.97)
- étape Compound —permet→ capitalisation des leçons apprises en docs/solutions réutilisables (CONCEPT, 0.96)
- Compound Engineering —recommande→ règle 50/50 (features / amélioration système) (CONCEPT, 0.93)
- Compound Engineering —recommande→ environnement agent-native (CONCEPT, 0.95)
- Every —publie→ plugin Compound Engineering (TECHNOLOGIE, 0.97)
- plugin Compound Engineering —permet→ review multi-agents P1/P2/P3 (CONCEPT, 0.95)
- plugin Compound Engineering —s_applique_à→ Claude Code, Cursor, Codex (TECHNOLOGIE, 0.94)
- Every —mesure→ 5 produits opérés par des équipes d'une personne (MESURE, 0.95)
- Kieran Klaassen —dirige→ Cora (TECHNOLOGIE, 0.97)
- Compound Engineering —affirme_que→ « Plans are the new code » (CITATION, 0.92)
- Kieran Klaassen —affirme_que→ l'adoption du compound engineering commence au stade 3 (plan-first, review niveau PR) (AFFIRMATION, 0.9)
- Kieran Klaassen —affirme_que→ first attempts ont 95% de déchet (AFFIRMATION, 0.88)
- /lfg —permet→ développement idée vers PR mergée (CONCEPT, 0.92)
- Compound Engineering —est_instance_de→ SDLC (METHODOLOGIE, 0.88)

---
Canonical: https://www.thekb.eu/en/fiches/klaassen-compound-engineering-definitive-guide-every-2026-02-09/