Compound engineering: how every fix makes the next one cheaper

Most engineering organisations treat knowledge as disposable. A bug gets fixed, the PR gets merged, and the lesson lives in someone's head until they leave.

Compound engineering is a different model. Every completed feature makes the next one easier to build. Every bug fix teaches the system permanently. Every code review finding becomes a rule that prevents the same class of issue from ever reaching review again.

The core loop

The methodology has four phases:

1. Plan — Agents research the codebase, read accumulated context files, and produce detailed implementation plans with objectives, architecture, and success criteria.
2. Work — Agents build code and tests to the plan, using tool calling and MCP to iteratively test as they go.
3. Assess — Both AI and humans review. Parallel review agents check different angles: security, performance, complexity. Linters and tests run automatically.
4. Compound — Learnings from all previous steps feed back into persistent context files. Best practices get distributed automatically.

The key insight: roughly 80% of effort is in planning and assessment. Only 20% is execution. The execution is the easy part once the knowledge layer is rich enough.

What compounds

The compounding happens through persistent files that agents reference before every conversation. One-time solutions become reusable patterns:

• Code review findings become linting rules
• Bug fixes become test patterns
• Architectural decisions become planning templates
• Performance fixes become constraints that prevent regressions

Every time you fix something, the system learns. Every time you review something, the system learns. This turns linear work into exponential productivity.

The tradeoffs are real

What you gain: Single developers accomplishing work that previously required five engineers. New team members inheriting accumulated expertise immediately. Quality improving over time without additional effort.

What it costs: Heavy upfront investment in the knowledge layer. Discipline to actually document learnings — the "compound" step is the easiest to skip. And the system is only as good as the review quality feeding it.

Why this matters now

This isn't theoretical. Teams building with AI agents are discovering that the bottleneck isn't code generation — it's context. The model can write code fast, but it writes better code when it knows what the team has already learned.

The engineering organisations that build this feedback loop early will compound their advantage. The ones that treat AI as "faster typing" will keep solving the same problems.