Compound Engineering workflow for AI-assisted development. Use when planning features, executing work, reviewing code, or codifying learnings...
This skill implements Compound Engineering—a development methodology where each unit of work makes subsequent work easier, not harder. Inspired by Every.to's engineering approach.
Each unit of engineering work should make subsequent units of work easier—not harder.
Traditional development accumulates technical debt. Every feature adds complexity. Every change increases maintenance burden. Compound engineering inverts this by creating a learning loop where each bug, failed test, or problem-solving insight gets documented and used by future work.
Plan → Work → Review → Compound → (repeat)
80% of compound engineering is in planning and review. 20% is in execution.
Before writing any code, create a comprehensive plan. Good plans start with research:
git log to understand how related features were builtCreate a plan document (markdown) with:
# Feature: [Name]
## Context
- What problem does this solve?
- Who is affected?
- What's the current behavior vs desired behavior?
## Research Findings
- Similar patterns found in codebase: [list with file links]
- Relevant prior implementations: [commit references]
- Best practices discovered: [external references]
## Acceptance Criteria
- [ ] Criterion 1 (testable)
- [ ] Criterion 2 (testable)
- [ ] Criterion 3 (testable)
## Technical Approach
1. Step 1: [specific action]
2. Step 2: [specific action]
3. Step 3: [specific action]
## Code Examples
[Include code snippets that follow existing patterns]
## Testing Strategy
- Unit tests: [what to test]
- Integration tests: [what to test]
- Manual verification: [steps]
## Risks & Mitigations
- Risk 1: [mitigation]
- Risk 2: [mitigation]
Execute the plan systematically:
# After each change, verify:
npm run typecheck # or equivalent
npm test # run affected tests
npm run lint # check code quality
Before merging, perform comprehensive review:
Code Quality
Security
Performance
Testing
Architecture
Consider the code from different angles:
This is where the magic happens—capture learnings to make future work easier:
Patterns: Document new patterns discovered or created
## Pattern: [Name]
When to use: [context]
Implementation: [example code]
See: [file reference]
Decisions: Record why certain approaches were chosen
## Decision: [Choice Made]
Context: [situation]
Options considered: [alternatives]
Rationale: [why this choice]
Consequences: [trade-offs]
Failures: Turn every bug into a lesson
## Lesson: [What Went Wrong]
Symptom: [what was observed]
Root cause: [actual problem]
Fix: [solution]
Prevention: [how to avoid in future]
After completing work, ask:
Document these in the appropriate location so future agents (and humans) benefit.
Plan implementation for: [describe feature]
- Research the codebase for similar patterns
- Check git history for related changes
- Create a detailed plan with acceptance criteria
- Include code examples that match existing patterns
Execute this plan: [plan reference]
- Create feature branch
- Break into TODO list
- Work through systematically
- Run tests after each change
- Create PR when complete
Review this change: [PR/diff reference]
- Check for code quality issues
- Look for security concerns
- Evaluate performance implications
- Verify test coverage
- Suggest improvements
Compound learnings from: [work just completed]
- What patterns were used or created?
- What decisions were made and why?
- What failures occurred and how to prevent them?
- Update AGENTS.md with relevant guidance
You're doing compound engineering well when:
Remember: You're not just building features—you're building a development system that gets better with each use.
