# The Era of Compound Engineering — Kieran Klaassen, Every/Cora

## Executive summary

The talk introduces 'Compound Engineering,' a methodology for building complex software products using AI by shifting focus from writing code to optimizing the system's memory and knowledge base. The core principle is that development efficiency increases when time is spent teaching the AI what it got wrong (system refinement) rather than just generating new features. This process inverts complexity accumulation, aiming for each subsequent feature to be easier to build than the last.

## Key takeaways

- The Compound Engineering Loop: The development loop involves Brainstorming $\rightarrow$ Planning $\rightarrow$ Working $\rightarrow$ Reviewing $\rightarrow$ Polishing $\rightarrow$ Compounding. The human must be 'brain-on' at both the start (defining the problem) and the end (raising the bar/taste).
- The 50/50 Rule of Improvement: Allocate 50% of time to building the feature and 50% to teaching the system what it did wrong or how it can learn. This knowledge extraction is crucial for long-term efficiency.
- Token Efficiency through Memory: Storing solutions and learnings within a repository (compounding) makes future interactions more token-efficient because the AI does not need to perform deep research or correction passes; the solution is already embedded.
- Inverting Complexity: The goal of Compound Engineering is that each shipped feature makes the next one easier, counteracting the typical accumulation of complexity in software development.

## Technical details

- Cora (Product): A complete AI email inbox and agent-native product built by the speaker, demonstrating the methodology in action. It runs on desktop, phone, CLI, etc.
- CE ID (Command): A plugin command used to analyze open tickets across multiple sources (GitHub, Slack, Intercom) and generate structured arguments on what is best to work on versus what should be deprioritized.
- C do review (Command): A utility that provides sharp questions when reviewing documents like PRDs, forcing the user to consider blind spots and generating knowledge for compounding.
- LFG (Automation Loop): The automated loop function that handles planning, working, reviewing, testing, opening a PR, and even performing before/after video screenshots in the pull request.

## Practical implications

- Focus on building a system that remembers and compounds knowledge (memory systems) rather than just writing code.
- When developing with AI, dedicate half the effort to refining the process and teaching the model its mistakes, not just shipping features.
- Use structured commands (like `CE ID` or `C do review`) to force critical thinking and document reasoning, thereby improving future iterations.
- The goal of automation should be creating a 'middle' that runs itself so well that human intervention is only required at the start (defining the problem) and the end (raising the bar).

## Topics

Compound Engineering, AI Development Workflow, Knowledge Management, Productivity Systems, Software Architecture, Cora, Every

Source: https://www.youtube.com/watch?v=_ehJyfHg1Vk