Compounding Engineering: The 4-Step Loop

Most engineering makes the next feature harder.

Every new feature adds complexity. More code to maintain. More edge cases to handle. More things that break when you change something else. It’s entropy. The codebase decays. Progress slows.

What if it worked the other way?

Why Traditional Engineering Slows Down

Here’s the pattern everyone knows:

The first feature ships fast. The second takes a bit longer. By the tenth feature, everything is a slog. Each change touches three systems. Each bug fix creates two more. The team spends more time maintaining than building.

This isn’t a skill problem. It’s a process problem. Traditional engineering adds complexity by default. Without deliberate effort, codebases become harder to work with over time.

Traditional Engineering	Compounding Engineering
Each feature adds complexity	Each feature reduces complexity
Tribal knowledge accumulates	Knowledge gets codified
Onboarding takes months	New hires productive on day one
Only original authors understand the code	Anyone can contribute anywhere
Velocity decreases over time	Velocity increases over time

The difference isn’t talent. It’s system design.

The Compounding Engineering Loop

Dan Shipper at Every runs six business units and four software products with 15 people. Not side projects—real products with thousands of paying subscribers. How? 99% of their code is written by AI agents.

That’s not the interesting part.

The interesting part is how they work with those agents. They call it Compounding Engineering. The goal: make sure each feature makes the next feature easier to build.

It’s a four-step loop:

PLAN → DELEGATE → ASSESS → CODIFY (and repeat)

The magic is in the last step.

Step 1: Plan

Before you touch an AI tool, plan in detail.

Not a vague idea of what you want. A detailed breakdown of how it should work. Architecture decisions. Edge cases. Integration points. Error handling.

Why this matters: AI agents execute what you describe. Vague input produces vague output. Detailed input produces working code.

What planning looks like:

Bad plan: “Add user authentication”

Good plan: “Implement email/password authentication using NextAuth.js. Store sessions in database. Add middleware to protect /dashboard routes. Include password reset flow with email verification. Handle edge cases: expired tokens, rate limiting on login attempts, account lockout after 5 failed attempts.”

The planning step is where your expertise pays off. You know the edge cases. You know what breaks in production. You know what the AI doesn’t know.

Write it down before you delegate.

Step 2: Delegate

Hand the plan to an AI agent. Let it execute.

This is the step that looks like magic to outsiders. You describe what you want. The agent writes the code. It creates files, installs dependencies, handles boilerplate.

But delegation isn’t abdication. You’re watching. You’re ready to intervene. You redirect when it goes wrong.

Delegation tips:

• Use detailed prompts, not one-liners
• Reference existing code patterns (“follow the pattern in /lib/auth”)
• Include constraints (“no external dependencies for this feature”)
• Break big tasks into smaller chunks

The agent does the typing. You do the directing.

Step 3: Assess

Test everything. Review the code. Try to break it.

Assessment has multiple layers:

1. Automated tests — Does it pass the test suite?
2. Manual testing — Does it actually work as expected?
3. Code review — Is the code maintainable?
4. Agent review — Have the AI explain what it did and why

The agent review step catches subtle issues. Ask the AI to explain its implementation choices. If the explanation doesn’t make sense, the code probably has problems.

Assessment questions:

• Does this handle the edge cases from the plan?
• Will this be easy to modify later?
• Does it follow existing patterns?
• What breaks if this fails?

Assessment is where senior judgment matters most. You catch what the AI missed.

Step 4: Codify

This is the money step.

Everything you learned from planning, delegating, and assessing—compound it back into prompts. Turn solved problems into prompts that solve them forever.

What to codify:

• Patterns that worked — Save as prompt templates
• Edge cases you discovered — Add to planning checklists
• Instructions that confused the agent — Rewrite for clarity
• Code patterns to follow — Document in a Claude.md or rules file

Example:

You just built an authentication system. The AI missed rate limiting on the first attempt. You caught it in assessment and added it.

Codify it:

Add to your auth prompt template: “All authentication endpoints must include rate limiting. Max 5 attempts per minute per IP. Account lockout after 5 consecutive failures with email notification.”

Next time you build auth—or anyone on your team does—that edge case is handled automatically.

This is how complexity decreases instead of increases. Every problem you solve gets codified. Every solution compounds.

The Second-Order Effects

When you run Compounding Engineering consistently, unexpected things happen:

1. New hires are productive on day one.

All the context, patterns, and best practices live in prompt files. A new developer points their AI agent at the codebase and starts contributing immediately. No six-month onboarding. No tribal knowledge gatekeeping.

2. Non-engineers can contribute code.

Managers, designers, product people—anyone who can describe what they want clearly can submit working code. The AI handles the syntax. The Codify step handles the patterns.

3. Cross-team contributions become normal.

Developer on Team A hits a bug in Team B’s codebase. They read the prompt files, understand the patterns, fix the bug, submit a PR. Done. No multi-day context-gathering.

4. Stack standardisation becomes optional.

One team uses React. Another uses Vue. Doesn’t matter. The AI translates between stacks. The Codify step captures intent, not implementation details.

5. Expertise gets distributed, not hoarded.

When a senior developer solves a hard problem, they don’t just commit code. They codify the solution. Now everyone can solve that problem.

First Thing Tomorrow

Start with Codify. You don’t need to overhaul your entire process. Just start capturing what works.

1. Pick one problem you solved this week. Something tricky. Something you’ll encounter again.
2. Write the prompt that solves it. Be specific. Include the edge cases. Include what the AI got wrong the first time and how you fixed it.
3. Save it somewhere your team can find it. A docs folder. A prompt library. A Claude.md file in your repo.
4. Use it next time. When the same problem comes up, use the prompt. Notice what’s missing. Update it.
5. Repeat. Every solved problem becomes a prompt. Every prompt compounds.

That’s the loop. Plan. Delegate. Assess. Codify. Each cycle makes the next one easier.

The Bottom Line

Traditional engineering is a losing game. Each feature adds weight. Velocity decreases. The codebase becomes a liability.

Compounding Engineering flips the equation. Each feature adds capability. Velocity increases. The codebase becomes an asset.

The difference is the Codify step.

Stop letting solved problems disappear into commit history. Start compounding them into prompts that solve them forever.

---

---

Want help building a Compounding Engineering practice in your team? The loop is simple. The execution takes discipline. Let’s talk about what works.