compound engineering with Claude Code: the loop, and the step everyone skips

There's an idea moving through AI-assisted development that matters more than any single tool: each unit of work should make the next one easier, not harder. Kieran Klaassen and Dan Shipper at Every named it compound engineering, and they run several products with near-single-person engineering teams on the back of it. The claim is simple, and once you feel it, hard to give up: most teams' AI output stays flat — every task starts from zero — while a compounding team's output curves upward, because the system keeps the lessons.

the loop

Compound engineering is usually drawn as a four-step loop:

• Plan — before any code, agents research the codebase, the conventions, and the framework versions, and produce a plan you correct.
• Work — the plan drives implementation; the agent builds the feature and its tests.
• Assess — review agents check the work for correctness, security, and architecture.
• Compound — the learnings from this task get captured into durable rules and docs the system reads next time.

The first three steps are what most people already mean by "using AI to code." The fourth is the one that actually compounds — and it is the one almost everyone skips.

the plugin is not the point

Every ships compound engineering as an open-source Claude Code plugin: a set of /ce: commands that scaffold the plan, run the work, and run the review. It is a good on-ramp, and if you live in the terminal it is a clean way to adopt the loop. But the plugin is a way to get the loop; it is not the loop. The loop is a discipline. And the hard part of the discipline is not typing /ce:plan — it is doing the Compound step honestly, every time, when you are tired and the feature already works.

where the do-it-yourself version leaks

Run the loop by hand for a few weeks and the same leaks show up:

• The Compound step is optional, so it doesn't happen. Capturing what you learned is unglamorous, and nothing breaks if you skip it — so it gets skipped, and the system stops compounding.
• Memory is scattered. Lessons end up as ad-hoc edits to an ever-growing CLAUDE.md, or in your head. There is no record of why a decision was made, or that the agent was corrected on exactly this point last time.
• Nothing is gated. The loop is a convention, not a wall. When you are moving fast, work slips from plan straight to merge, and the Assess and Compound steps quietly fall off.

(The underlying version of this — how decisions and context drift across agents — is its own problem; we went into it in keeping context and decisions consistent across parallel AI agents.)

building the loop in, instead of bolting it on

This is the problem defract was built around, so take it as one approach rather than the only one. Instead of assembling the loop from commands you have to remember to run, defract makes it the structure of the product: a task moves through scope → design → architecture → implementation → review → release, and the stages are gated. Review is a real checkpoint, not a suggestion you can skip on a fast day. That covers Plan, Work, and Assess by construction.

The Compound step is the interesting part. defract keeps a memory of your project — conventions, decisions, mistakes, and the moments you stopped and redirected an agent — and a consolidation pass extracts those learnings after a task, rather than relying on you to write them down. That memory is fed back into the next task's agents by relevance. In defract's own framing, memory is the compounding layer: the more you use it, the better it gets at building your software. That is the Compound step made structural instead of optional.

so, can you bring your compound-engineering plugin?

Honest answer, since it comes up: you do not run the /ce: plugin inside defract's pipeline. defract's stage agents run with their own fixed prompts — a deliberate choice, to keep Claude Code's prompt cache stable across stages — so a plugin's slash commands are not part of that pipeline. The reason you would not want them to be is that defract is the loop; running a second loop inside it is running the same play twice. Your raw Claude Code setup — your CLAUDE.md, your subagents, your MCP servers — still works when you drop into defract's plain chat or build mode, the same as an ordinary Claude Code session.

The takeaway is not "use this tool." It is that the loop is the point, and the Compound step is the part that earns the name. Whether you assemble it from a plugin or get it built into the workflow, the question worth asking is the one most AI coding setups never answer: a month from now, will the system be better at building your product — or just as fluent, and just as forgetful, as it is today?