A couple of years ago, the conversation in AI-assisted engineering centered on a simple question: can the model write code that actually works? Hallucinations, wrong APIs, logic errors — the failure mode was the output itself. That era is largely over. The models improved, tooling caught up, and the remaining failures became manageable with better review loops and planning prompts.
What replaced it as the hard problem is less obvious: repetition. Specifically, the repetition of human judgment.
The Bottleneck Has Moved
Every practitioner who works closely with an AI coding tool will recognize the pattern. The model produces something reasonable. A correction gets made, or a choice gets overridden, or a preference gets restated for the third time that week. The next session starts fresh. The same correction happens again. Multiply that across weeks, features, and teammates, and an enormous share of the productivity gain quietly leaks out.
The insight behind compound engineering is that this is not inevitable — it is an architectural choice. When every judgment call made during a development session gets captured into a persistent knowledge system (essentially a set of decision documents stored in the repository), it can be loaded into the model’s context in future sessions. The model stops repeating the same mistakes. Each correction becomes, in effect, a one-time cost.
The core loop runs like this: brainstorm, plan, build, review, polish — then compound. The compounding step is the one most teams skip. It is also the one that determines whether the system gets smarter over time or stays flat.
The Human-AI Sandwich
The working model that emerges from this approach is worth sitting with. The human is active at two points: the start (deciding what to build, framing the problem, setting the direction) and the end (polishing the result, raising the bar, judging whether it actually meets the intent). The middle — planning, coding, review, testing — runs autonomously. If a developer is still being pulled into that middle loop regularly, the system is not done yet.
This reframes what “productivity” means in an AI-assisted workflow. The instinct when something goes wrong in the middle is to dive in and fix it. Compound engineering says: fix it once, then immediately convert that fix into a durable entry in the knowledge base. The next time the same situation arises, the system handles it without the human. The time saved is not linear — it accumulates.
What Gets Captured
The principle “document the thinking, not the code” is a useful frame here. The code is already the artifact. What tends to get lost — and then has to be reconstructed — is the reasoning: why this approach over that one, why this data model, why this library at this particular moment in the project’s life. When a build goes wrong, a lightweight postmortem that identifies the specific decision that caused the failure and converts it into a system-level behavior change is more durable than any individual fix. The pattern to look for is any moment of correction: that is a signal to extract and compound, not just to patch and move on.
Over time, the effect inverts the usual trajectory of a growing codebase. Normally, complexity accumulates and each new feature carries a heavier weight of history. Here, each feature is supposed to make the next one cheaper — because the judgment that went into it now lives in the system rather than only in the developer’s head.
The Leverage Shift
For most of software development’s history, scaling output meant scaling headcount. The AI coding era suggested an alternative: one person with good tooling could match a small team. Compound engineering suggests the real leverage comes not from the tooling itself but from what gets deposited into a shared knowledge system over time. Two teams using the same models but with different compounding habits will diverge — the one systematically capturing its decisions will pull progressively further ahead.
The productivity gains from AI-assisted development are real, but they are not automatic. How much human judgment compounds back into the system — and how consistently — is emerging as the variable that separates teams that sustain those gains from teams that plateau.
As agents become more capable and take on longer, more autonomous tasks, the teams with the richest accumulated knowledge bases will be the ones able to safely extend that autonomy. The question worth sitting with now is not which model to use or which agent runtime to adopt — it is what the team is actually doing to ensure that the good decisions made today are still shaping decisions six months from now.
Text summarized and optimized using Anthropic’s models and reviewed by a human.