Compound Engineering in Claude Code: Operator's Guide

Compound engineering is Every's methodology for working with coding agents so that each unit of work makes the next one easier: plan, work, review, then compound, writing what the cycle taught you into files the next session reads. Kieran Klaassen developed it building Cora, Every's AI email product, and Every ships it as an open-source plugin with 33 skills that run on Claude Code, Cursor, and a dozen other harnesses (24.5k GitHub stars as of 2026-08-24).

Their guide explains the philosophy well. This page adds AI Builder Club's operator view: what running this looks like day to day, which parts carry the value, what to measure before trusting it, and where its limits sit. We run agent systems in production for a living, which is where that view comes from. The methodology stays Every's throughout; the judgments are ours and labeled.

The Cycle, as You Actually Run It

Plan. The idea becomes a written blueprint before any code. The plugin's commands feed this: its ideation skill grounds in the repo, past solution docs, and web prior art, optionally drawing on Slack or an issue tracker; its document-review skill dispatches parallel reviewer personas, applies only full-confidence mechanical fixes, and routes the remaining findings; its brainstorm skill asks one decision at a time and writes a requirements-only plan. The methodology's weighting is unambiguous: most of the effort belongs here and in review, not in the coding.

Work. The agent implements. The span of autonomy is yours to set: drive it in-session, or hand the whole thing to /lfg, which plans, implements, runs multi-agent review, applies the fixes, runs browser tests, commits, pushes, opens a PR, and watches CI without you. Klaassen's stated practice is to let this run overnight, in parallel, across features. The July 2026 update made this multi-model: high-reasoning steps can route to a second frontier model inside planning, and a babysit-PR skill watches a pull request for hours after push.

Review. The guide's instruction is multiple agent reviewers, then agent-applied fixes. The plugin's polish pass is explicitly framed as raising the bar, not QA. Human judgment concentrates where Klaassen's human-AI sandwich puts it: at the start (what to build and why) and at the end (does this meet a bar that lives partly in your head). The failure mode, in our framing: brain off in the middle is fine; brain off at the ends is where things break.

Compound. The step that names the methodology, and, in our operator's judgment, the only step that changes your slope. The plugin's compound skill captures one reusable learning per run in docs/solutions/, with an optional consented pointer added to AGENTS.md or CLAUDE.md for discoverability. In the broader practice Every's guide describes, teams also update instruction files and add agents or skills when a learning warrants it. Klaassen's discipline for it is the 50/50 rule: half your time on the feature, half teaching the system what went wrong. His stated standard for the whole practice: the next feature should be easier because you shipped this one.

The compound step's output is a written spec of how your work is done and judged, which is exactly the raw material an unattended loop needs. When a compounded job starts recurring, the Loop Engineering course is the discipline for the handover: turning your accumulated checklist into a verifier and the job into something that runs on a schedule without you.

The Six-Stage Ladder, and Where to Locate Yourself

Every's guide sketches six stages of practice: manual coding; chat copy-paste; agentic in-session work; plan-first with PR-only review; idea-to-PR autonomy (/lfg); and parallel agents running off your machine, monitoring feedback and proposing fixes without being asked. Klaassen locates himself at the last stage for some work and the plan-first stage for other work simultaneously, which is the honest shape: the stage is a property of each job, not of you. Grant autonomy per job, as the compound files for that job get good enough to deserve it.

The guide's list of beliefs to let go is the fastest way to locate yourself: that code must be hand-written, that every line must be manually reviewed, that the first attempt should be good, that more typing means more learning. If several of those still feel true, start at plan-first rather than /lfg, and let the compound step earn the autonomy increase.

What to Measure Before You Trust It

No public benchmark compares compound engineering against plain disciplined agent use, and Every does not publish one. The productivity claims around it are testimony, including Klaassen's own. That does not make it unverifiable; it makes it verifiable only in your repo. We use three cheap checks:

1. Repeat-mistake rate. The same class of error appearing in cycle after cycle means the compound step is writing files nobody reads, or nothing at all.
2. Plan quality without prompting. A working system starts referencing past decisions and known gotchas in new plans unprompted. If every plan reads like the agent's first day, the knowledge is not landing.
3. Correction cost per feature. The methodology's own standard, made measurable: is feature N+1 taking fewer review rounds and fewer taste corrections than feature N? Klaassen's three-hour version of the same test: when a long autonomous run comes back consistently good, the system is working.

We call the failure mode the factory trap: spending your time building the compounding machinery instead of the product. We use the 50/50 rule as the guardrail; if the split drifts toward the system and the shipped-work column stalls, cut back to the cycle's basics.

Where It Stops Being Compound Engineering

Two boundaries:

• Recurring jobs. Compound engineering organizes units of work. When a job recurs on a schedule, it is an operation, and it needs a trigger, state, a stop condition, and an executable verifier: loop territory. The compound files you accumulated are the loop's spec; that graduation path is the best thing about running both frames.
• Multiple agents needing coordination. When one agent's cycle is not enough and you wire several together, you are in graph territory, and the discipline shifts to topology: nodes, edges, and who checks whom.

For feature work with a coding agent, the methodology's core bet is the one Klaassen states plainly: implementation keeps getting cheaper, judgment does not. The compound step is a way to record that judgment for reuse. That part, in our experience running the adjacent discipline daily, holds.

Related Content

• Compound Engineering vs Loop Engineering - The boundary in full: units of work that teach the next one vs operations that run themselves.
• Loop Engineering: Stop Writing Prompts, Start Writing Verifiers - The discipline a compounded job graduates into when it starts recurring.
• The Evolve Loop: Loops That Rewrite Themselves - The compound step running inside an unattended loop: a process that updates its own contract.
• Graph Engineering Guide (2026) - The other boundary: when one agent's cycle is not enough.
• How to Become an AI-Native Company - The company-scale version of granting autonomy job by job.

Join AI Builder Club