Compound Engineering
Compound engineering is a methodology coined by Kieran Klaassen at Every where development teams design systems with persistent memory so AI agents learn and improve with each task completed. Rather than traditional engineering where each feature compounds complexity, compound engineering inverts this paradigm—every pull request, bug fix, and code review updates the system’s defaults, making subsequent work exponentially faster.
Core Concept
The fundamental principle: knowledge compounds rather than complexity compounds.
In traditional development:
- Each feature adds code complexity
- Teams repeat similar workflows
- Knowledge exists in ad-hoc places (docs, PRs, slack threads)
- New features always feel like starting from scratch
In compound engineering:
- Each completed task teaches the system how to handle similar tasks
- Workflows are codified and improved iteratively
- Knowledge persists in the system’s context
- Development velocity increases over time
Key Principles
1. Codified Workflows
Document how you work so AI can execute and improve it next time. Rather than manually repeating tasks, create reusable workflow specifications that agents can follow and enhance.
2. Building Prompts That Build Prompts
Layer prompts to create cascading value. Example from Every:
- Initial prompt generates research documents
- Research documents become implementation prompts
- Implementation agents create code
- Code reviews feed back into system defaults
3. Pattern Capturing Over Brittle Automation
Use natural-language rules and patterns that adapt across contexts rather than rigid workflow-based automation. This allows the system to generalize learning across different scenarios.
4. Agent Orchestration
Deploy multiple AI agents in parallel like a distributed team:
- Frontend agent
- Backend agent
- Testing agent
- Documentation agent
Each agent works autonomously on its domain, with human orchestrators handling architecture and design review rather than syntax checking.
The Compound Engineering Loop
The workflow operates in three phases:
Phase 1: Plan
- Agents read issues and requirements
- Research approaches and best practices from codebase
- Synthesize information into detailed implementation plans
- Create structured GitHub issues with step-by-step breakdown
Phase 2: Work
- Agents write code according to plans
- Agents create comprehensive tests
- Parallel execution across multiple agents
- All work fed back into codified workflows
Phase 3: Review
- Human orchestrators review architecture and design decisions
- Not syntax-level review (agents handle this)
- Feedback updates system defaults for next iteration
- Each decision teaches the system
Practical Implementation
Tools & Stack
- Development environment: Claude Code with multiple concurrent instances
- Version control: GitHub with detailed issue templates
- Coordination: Voice input (Klaassen uses voice-to-Claude for task description)
- Context: Codebase and documentation accessible to agents
Workflow Example
- Speak feature idea into Claude Code (voice input)
- Agent researches best practices and codebase patterns
- Agent creates detailed GitHub issue with implementation plan
- Agent spawns parallel agents for different components
- Agents work autonomously on their tasks
- Human reviews architecture and design
- Feedback loop updates system knowledge
Key Insight: Manager as Orchestrator
Managers are particularly well-positioned to orchestrate AI agents because they already understand:
- Task decomposition
- Team coordination
- Cross-functional dependencies
- Risk identification
Metrics & Results
The methodology tracks:
- Development velocity increases per iteration
- Code quality improvements (fewer bugs in subsequent features)
- Knowledge reuse across similar tasks
- Time-to-first-implementation on new features
At Every, this approach enabled the team to move faster as they built more, inverting the typical trajectory where technical debt slows progress.
Broader Applications
Compound Leadership
The principles extend beyond engineering to organizational governance through “compound leadership”:
- Scale human judgment through secure human-AI collaboration
- Maintain control and accountability as systems become more autonomous
- Create transparent, disciplined systems for complex decisions
- Build organizational memory that compounds over time
Distinction from Traditional AI-Assisted Dev
Traditional AI development:
- Prompt → Get code → Ship → Start over
- No accumulated learning
- Each task feels isolated
- Context reset between iterations
Compound engineering:
- Codify workflow → Agent executes → Learn from output → Update system
- Accumulated knowledge persists
- Each task accelerates the next
- Context compounds exponentially
Related Concepts
- Agent Orchestration
- Prompt Engineering (especially multi-layer prompts)
- Code Generation
- AI-Assisted Development
References
- Original concept by Kieran Klaassen at Every
- Practical implementation in Cora (Every’s email product)
- Part of broader movement toward AI-first software development
Last updated: January 2025
Confidence: High (direct source from Kieran Klaassen at Every)
Practical application: Actively used in production at Every