# Compounding Engineering: The 4-Step Loop — Pilot to Production

> Most engineering makes the next feature harder. Compounding engineering flips it: a Plan, Delegate, Assess, Codify loop where each cycle makes the next easier.

Canonical: https://thegrowthproject.com/podcast/compounding-engineering/

*Pilot to Production*, the Growth Project podcast — hosted by Sam and Maya.

- Listen: https://thegrowthproject.com/podcast/compounding-engineering/
- Read the article: https://thegrowthproject.com/blog/compounding-engineering/
- Audio: https://thegrowthproject.com/audio/podcast/compounding-engineering.m4a?v=0dd63022

## Transcript

**Sam:** Dan Shipper runs six business units and four software products. Real products, thousands of paying subscribers.

**Maya:** With fifteen people. And ninety-nine percent of their code is written by AI agents.

**Sam:** Okay, that number should not be possible.

**Maya:** It isn't, unless you change how the work works. Which is the whole story.

**Sam:** Welcome to Pilot to Production, from the Growth Project. I'm Sam.

**Maya:** And I'm Maya. Today: compounding engineering, the four-step loop where every feature makes the next one easier.

**Sam:** So start with the thing that's bugging me. Most engineering does the opposite, right?

**Maya:** Right. Most engineering makes the next feature harder. Every feature adds complexity. More code to maintain, more edge cases, more things that break when you touch something else.

**Sam:** Entropy. The codebase decays, progress slows. First feature ships fast, by the tenth everything's a slog.

**Maya:** Exactly that. Each change touches three systems. Each bug fix creates two more. The team spends more time maintaining than building.

**Sam:** And your point is, that's not a talent problem.

**Maya:** It's a process problem. Traditional engineering adds complexity by default. Compounding engineering flips it, so each feature reduces complexity instead.

**Sam:** How? That sounds like a slogan until you show me the loop.

**Maya:** Four steps. Plan. Delegate. Assess. Codify. And repeat.

**Sam:** Walk me through plan.

**Maya:** Before you touch an AI tool, you plan in detail. Not a vague idea. Architecture, edge cases, integration points, error handling.

**Sam:** Give me bad versus good.

**Maya:** Bad plan: "add user authentication." Good plan: email and password auth with NextAuth, sessions in the database, middleware on the dashboard routes, password reset with email verification. And the edge cases, expired tokens, rate limiting, account lockout after five failed attempts.

**Sam:** That's where the senior actually earns their keep. They know what breaks in production.

**Maya:** They know what the AI doesn't know. Then step two, delegate. Hand the plan to an agent, let it write the code.

**Sam:** That's the part that looks like magic to outsiders.

**Maya:** But delegation isn't abdication. You're watching, ready to intervene, you redirect when it goes wrong. The agent does the typing, you do the directing.

**Sam:** Then assess. Which I assume is more than "tests pass."

**Maya:** Four layers. Automated tests, manual testing, code review, and agent review. You have the AI explain what it did and why.

**Sam:** And if the explanation doesn't make sense?

**Maya:** The code probably has problems. Assessment is where senior judgment matters most. You catch what the AI missed.

**Sam:** Okay, three steps in and it just sounds like good engineering. Where's the part that compounds?

**Maya:** Step four. Codify. The money step. Everything you learned planning, delegating, assessing, you compound it back into prompts.

**Sam:** Make it concrete.

**Maya:** You build that auth system. The AI misses rate limiting first time. You catch it in assessment. Then you codify it: add to the prompt template, every auth endpoint needs rate limiting, max five attempts per minute per IP, lockout after five consecutive failures with email notification.

**Sam:** So next time, that edge case is just handled. For anyone on the team.

**Maya:** Automatically. That's how complexity goes down instead of up. Every solved problem gets codified. Every solution compounds, instead of disappearing into commit history.

**Sam:** And there are knock-on effects beyond speed.

**Maya:** New hires are productive on day one, the context lives in the prompt files. Non-engineers can submit working code. A developer can fix a bug in another team's codebase by reading the prompts. Even the stack stops mattering, because you capture intent, not implementation.

**Sam:** Expertise gets distributed instead of hoarded.

**Maya:** When a senior solves a hard problem, they don't just commit code. They codify the solution, and now everyone can solve it.

**Sam:** So, first thing tomorrow. Where do I start?

**Maya:** Start with codify. Don't overhaul anything. Pick one tricky problem you solved this week, something you'll hit again. Write the prompt that solves it, including what the AI got wrong the first time.

**Sam:** Then save it where the team can find it.

**Maya:** A docs folder, a prompt library, a Claude dot M D file in the repo. Use it next time, notice what's missing, update it. Repeat. Every solved problem becomes a prompt, every prompt compounds.

**Sam:** This has been Pilot to Production, from the Growth Project. If your codebase is getting heavier instead of smarter, that's the gap we close, at thegrowthproject.com.

**Maya:** Thanks for listening. See you next time.