← back
The Era of Compound Engineering — Kieran Klaassen, Every/Cora
Takeaway
Capture your judgments and corrections as reusable knowledge so each completed task improves the next one.
Summary
- Klaassen describes building the Cora email product as a single primary engineer with support, progressively moving bottlenecks from code to planning, product judgment, and memory.
- The compound engineering loop runs through brainstorming, planning, implementation, review, polishing, and extracting lessons for reuse.
- Human attention concentrates on choosing the right problem and judging final quality, while the middle stages become increasingly autonomous.
- He advocates spending roughly half the effort on delivery and half teaching the system, storing solution documents in the repository to reduce repeated research and corrections; a plugin packages the workflow across coding tools.
compound-engineeringagent-memorycoding-workflows
Original description
He has not written a line of code this year, and has not read most of it either, yet he ships a full email client that thousands of people trust with their inbox. Kieran Klaassen has been rebuilding Cora alone since January, and the useful part of his account is the sequence of bottlenecks he moved through. Two years ago the code itself was bad, so he layered on review and skills until it got good. Then the plans were the constraint, until those got good too. Then knowing what to build at all. What was left after that was him repeating himself, which is what a memory system exists to fix. That is where compound engineering came from, and the rule attached to it is the demanding one. Spend half your time building the feature and the other half teaching the system whatever it got wrong. His counterintuitive claim is that this ends up cheaper in tokens rather than more expensive, because a stored solution means no correction pass and no research detour the next time around. The loop puts the human at both ends, brain on to decide what the problem actually is, then brain on again at the finish to raise the bar rather than to run QA, with hours of autonomous work in between. The bar he holds it to is that the next feature should be easier to build because this one shipped, which inverts the way complexity normally accumulates. Speaker info: https://x.com/kieranklaassen / kieran-klaassen https://cora.computer Timestamps: 0:00 - Shipping without writing or reading the code 2:52 - Building an email client alone, on purpose 4:40 - The bottleneck moved from code to plans to judgment 5:30 - Where compound engineering came from 6:25 - The loop, and the human at both ends 8:10 - Half your time teaching the system what it got wrong 9:03 - Why stored solutions are cheaper in tokens 9:55 - The plugin, and building it while building the product 10:45 - Turning a backlog into an argued set of ideas 12:26 - Sharp questions on a document, and only enough of them 15:01 - The overnight loop, and polish as raising the bar 17:33 - Doing this without the plugin 19:14 - The next feature should be easier than this one