# shipper-klaassen-compound-engineering-every-agents-2025-12-11

## Veille

Compound Engineering: a 4-step process (Plan, Work, Assess, Compound) for teams coding with AI agents - Every

## Titre Article

Compound Engineering: How Every Codes With Agents

## Date

2025-12-11

## URL

https://every.to/chain-of-thought/compound-engineering-how-every-codes-with-agents

## Keywords

compound engineering, AI agents, planning, code review, learning loop, Claude Code, Every, Cora, subagents, compounding, plugin, agentic workflow, spec-driven, 1 developer = 5, Playwright, MCP, Opus 4.5, SDLC, software development lifecycle, agentic SDLC

## Authors

Dan Shipper, Kieran Klaassen

## Ton

**Profile**: Perspective of a tech CEO (Shipper) and a product GM (Klaassen), accessible and enthusiastic register, intermediate level

**Description**: Dan Shipper adopts the tone of a practitioner's manifesto — he starts from a provocative observation ("100% of the code is written by agents, nobody codes manually") to unfold a process structured in 4 steps. The style is that of a founder sharing his internal practices with pride and pedagogy. The phrasing is punchy ("the hard part is almost over" after planning, "this is the money step" for compounding). The author draws on Every's real-world experience (5 products, each maintained by a single person) to lend credibility to a discourse that might otherwise seem utopian. The target audience consists of developers and technical leaders seeking to transform their practice with AI agents.

## Pense-betes

- **Compound engineering definition**: In traditional engineering, each feature makes the next one harder. In compound engineering, each feature makes the next one easier thanks to a learning loop documented for the agents and the team.
- **4-step loop**: 1. **Plan** (codebase + internet research → complete planning document) — ~40% of the time 2. **Work** (the agent executes the plan step-by-step, uses MCP/Playwright to test in real time) — ~10% 3. **Assess** (review by the agent + linters + tests + 12 parallel subagents, each with a different perspective) — ~40% 4. **Compound** (record the lessons learned for future sessions) — ~10%
- **Effort breakdown**: 80% Plan + Assess, 20% Work + Compound. The actual coding work is the simplest part.
- **Productivity ratio**: 1 developer with AI = 5 developers from a few years ago, based on Every's experience.
- **5 products, 1 person each**: Every runs 5 software products (including Cora, Spiral, Sparkle, Monologue) each primarily built and maintained by a single person, used by thousands of people daily.
- **Compound engineering plugin**: Open-source Claude Code plugin that implements Every's exact workflow. The review uses 12 parallel subagents (security, performance, complexity, etc.).
- **Tools**: Mainly Claude Code, but also Factory Droid and OpenAI Codex CLI. Tool-agnostic approach.
- **MCP Playwright/XcodeBuildMCP**: The agent uses the app like a user during development — writes code, navigates the app, identifies issues, iterates.
- **Compound step — the secret**: After each review, the agent summarizes the comments and stores them for future use. The lessons are automatically distributed to the whole team because they live in the codebase or the plugins. A new hire is as well-equipped as a veteran.
- **Cora routing questions**: Before building, the agent must ask itself: "Where does this go in the system? Should it be added to the existing code or should something new be created? Has a similar problem already been solved?"
- **What becomes obsolete**: Manually writing tests, writing "human-readable" code with extensive documentation, no-internet coding interview exercises, multi-week onboarding processes, technology lock-in caused by legacy systems.
- **Strong link to the watch corpus**: Foundational article of the compound engineering philosophy that runs through Klaassen (Stop Coding Start Planning, Teach AI Think Senior Engineer) and the Every/compound-engineering plugin.

## RésuméDe400mots

Dan Shipper and Kieran Klaassen present **compound engineering**, the engineering process developed at Every where 100% of the code is written by AI agents. The core principle is an inversion of complexity: in traditional engineering, each feature makes the next one harder; in compound engineering, each feature makes it easier, thanks to a learning loop that documents every bug, failed test, and insight for future agents.

The process breaks down into **four steps**. **Plan** (~40% of the time) begins with thorough research of the codebase, git history, and external best practices, after which the agent produces a complete planning document including the objective, proposed architecture, code examples, and success criteria. **Work** (~10%) is the simplest part: the agent executes the plan step by step, using MCP protocols like Playwright to test the application like a real user and iterate until satisfied. **Assess** (~40%) combines linters, unit tests, manual tests, and a system of 12 parallel subagents that evaluate the code from different perspectives (security, performance, complexity, architecture). **Compound** (~10%) is "the magic step": the lessons from each cycle are summarized by the agent and stored for future use.

Compound engineering works in practice at Every: **five software products** (Cora, Spiral, Sparkle, Monologue, and others), each primarily built and maintained by **a single person**, are used by thousands of users daily. The productivity estimate is that a well-equipped developer today does the work of five developers from a few years ago.

The primary tool is **Claude Code**, but the approach is tool-agnostic (Factory Droid and OpenAI Codex CLI are also used). Every has released an **open-source plugin** for Claude Code that implements the complete workflow, including the 12 review subagents.

The compounding mechanism is the key differentiator: the lessons learned live in the codebase as prompts, making every developer — including new hires — as well-informed as a veteran. Cora's agent, for example, must systematically ask itself where to place a feature within the system and whether a reusable precedent already exists.

The authors conclude that this approach renders many established practices obsolete: manually writing tests, exhaustive code documentation, no-internet coding interview exercises, and technology lock-in caused by legacy systems.

## GrapheDeConnaissance

- Dan Shipper —a_créé→ Compound Engineering (METHODOLOGIE, 0.95)
- Kieran Klaassen —a_créé→ Compound Engineering (METHODOLOGIE, 0.95)
- Compound Engineering —utilise→ Claude Code (TECHNOLOGIE, 0.97)
- Compound Engineering —utilise→ subagents (TECHNOLOGIE, 0.95)
- Every —utilise→ Compound Engineering (METHODOLOGIE, 0.98)
- Every —publie→ plugin Compound Engineering (TECHNOLOGIE, 0.96)
- Compound Engineering —améliore→ productivité développeur ×5 (CONCEPT, 0.9)
- Dan Shipper —affirme_que→ 1 développeur IA = 5 développeurs classiques (AFFIRMATION, 0.92)
- Cora —fait_partie_de→ Every (ORGANISATION, 0.98)
- Compound Engineering —est_basé_sur→ boucle Plan-Work-Assess-Compound (CONCEPT, 0.97)
- étape Compound —permet→ transformation des leçons apprises en contexte réutilisable (CONCEPT, 0.95)
- plugin Compound Engineering —utilise→ 12 subagents parallèles pour review (TECHNOLOGIE, 0.96)
- Kieran Klaassen —dirige→ Cora (TECHNOLOGIE, 0.97)
- Dan Shipper —dirige→ Every (ORGANISATION, 0.98)
- Compound Engineering —est_instance_de→ SDLC (METHODOLOGIE, 0.88)

---
Canonical: https://www.thekb.eu/en/fiches/shipper-klaassen-compound-engineering-every-agents-2025-12-11/