I’ve been thinking a lot about compounding lately. Not the finance kind — though you do that too — but the kind where your work gets easier over time instead of harder. I’m calling it Compound Engineering, and I think it might be the most important shift in how we work.
Here’s the thing that’s been bugging me. I’ve been building stuff for a long time. Software, hardware, IoT platforms, weird pinball mods — you name it. And every single time I start a new project, there’s this moment where I think, “Didn’t I already do this part?” The setup. The boilerplate. The config files. The architecture decisions I’ve already made a dozen times before.
I call it the Groundhog Day Problem.
Your tools don’t remember you. You close the tab, and it’s like you never existed.
“Sixty to eighty percent of what you do on a new project, you’ve already done before.”
Hans Scharler
And yet, every time, you start from scratch. That’s not a feature. That’s a bug.
TL;DR
The Work Surface That Learns
Compound Engineering is the idea that your work surface — the environment where you actually do the work — should learn, adapt, and accumulate knowledge over time. Not like templates. Templates are dead things. I’m talking about living intelligence that evolves with you.
Think of it like compound interest, but for productivity. Every workflow you capture, every pattern you codify, every piece of knowledge you extract — it doesn’t just help you today. It helps you tomorrow, next month, and next year. It accrues.
I’ve been experiencing this firsthand. When I wrote about The Engineering Super Stack, I was already circling this idea — stacking the right tools so they yield something greater than the parts. But Compound Engineering goes further. It’s not just about picking good tools. It’s about tools that get better because you used them.
Five Layers That Stack
When I break it down, there are five layers to this compounding:
Workflows are the foundation. You do something once, capture the sequence, and now you can replay it, remix it, evolve it. That deployment script you write from memory every time? Capture it. Done.
Skills take it further — encoding your domain expertise into reusable, shareable modules. The stuff that lives in your head? Make it executable.
Commands are where you start to feel the leverage. Those ten steps you do every Monday morning? Collapse them into one. One click. Gone.
Agents are where it gets fun. Autonomous workers that carry your intent forward while you’re doing something else — or sleeping, which I hear some people do.
Knowledge is the substrate beneath everything. Context that doesn’t just persist — it deepens and connects across projects, across teams, across your career.
Each layer feeds the next. That’s the compounding.
Project 1 vs. Project 10
Here’s how it plays out in practice:
Project one, you build everything from scratch. You’re exploring, making mistakes, learning. It’s slow, and that’s fine.
By project three, your workflows are captured. Setup takes half the time. You’re not reinventing the wheel anymore.
By project five, agents handle the boring parts. Boilerplate? Done. Config? Done. You’re spending your time on the interesting problems — the ones that actually need your brain.
By project ten, you describe what you want, and the system drafts the first 70%. You refine, you polish, you add the creative spark. But the heavy lifting? Already handled.
Project ten shouldn’t feel like project one. And now it doesn’t have to.
I’ve talked before about how empathic AI prompting changed the way I work — treating your AI like a collaborator instead of a vending machine. Compound Engineering is the next step. It’s not just about how you talk to your tools. It’s about your tools remembering every conversation you’ve ever had.
What Actually Changes
This isn’t incremental. This rewrites the economics of work.
Onboarding gets transformed. New team members don’t get a wiki link and a “good luck.” They inherit the team’s compound knowledge from day one — the workflows, the skills, the patterns.
Expertise becomes portable. When your best engineer moves on, their expertise stays. Codified, not tribal.
The gap between “senior” and “junior” shrinks. Not because junior developers suddenly gain ten years of experience, but because the tools carry the seniority. The tools know the patterns. The tools remember the pitfalls.
Solo operators gain the leverage of teams. Small teams gain the leverage of enterprises. That’s not a tagline. That’s just what happens when you make expertise executable.
The Risk of Not Doing This
I’ll be blunt. If you’re not compounding, you’re falling behind.
Linear workers — folks doing great work but starting from zero every time — hit a ceiling. There’s only so fast you can move when you’re rebuilding the foundation each time. Compound workers hit escape velocity. Same talent, same hours in the day, dramatically different output over time.
Organizations feel this even harder. Institutional knowledge that isn’t captured gets lost to attrition, to time, to entropy. Your best person leaves, and a decade of expertise walks out the door with them.
The future belongs to whoever builds the flywheel first.
Where This Is Going
I see three things coming.
- Connected work surfaces… where your tools talk to your teammates’ tools. Work surfaces that negotiate and share context without a meeting.
- Skills marketplaces… codified expertise becoming a tradeable asset. A senior DevOps engineer publishes their deployment workflow. A startup buys it and deploys like a Fortune 500 company on day one.
- Career-long AI… a personal AI that doesn’t reset when you change jobs. It compounds across your entire career. Every problem you’ve solved, every domain you’ve mastered, every lesson you’ve learned.
Start the Flywheel
Here’s your homework. Codify one workflow this week. Just one. That deployment script you always write from memory. The project setup you’ve done forty times. The onboarding checklist that lives in your head.
Write it down. Automate it. Make it reusable. Watch what happens.
