Skip to content
compound-engineering logo

Feature: [Name]

compound-engineering

Compound Engineering workflow for AI-assisted development. Use when planning features, executing work, reviewing code, or codifying learnings. Follows the Plan → Work → Review → Compound loop where each unit of engineering makes subsequent work easier. Triggers on: plan this feature, implement th...

SKILL.md

Full skill instructions

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.

Core Philosophy

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.

The Compound Engineering Loop

Plan → Work → Review → Compound → (repeat)
  1. Plan (40%): Research approaches, synthesize information into detailed implementation plans
  2. Work (20%): Execute the plan systematically with continuous validation
  3. Review (20%): Evaluate output quality and identify learnings
  4. Compound (20%): Feed results back into the system to make the next loop better

80% of compound engineering is in planning and review. 20% is in execution.

Step 1: Plan

Before writing any code, create a comprehensive plan. Good plans start with research:

Research Phase

  1. Codebase Analysis: Search for similar patterns, conventions, and prior art in the codebase
  2. Commit History: Use git log to understand how related features were built
  3. Documentation: Check README, AGENTS.md, and inline documentation
  4. External Research: Search for best practices relevant to the problem

Plan Document Structure

Create 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]

Detail Levels

  • Minimal: Quick issues for simple features (1-2 hours work)
  • Standard: Issues with technical considerations (1-2 days work)
  • Comprehensive: Major features requiring architecture decisions (multi-day work)

Step 2: Work

Execute the plan systematically:

Execution Workflow

  1. Create isolated environment: Use feature branch or git worktree
  2. Break down into tasks: Create TODO list from plan
  3. Execute systematically: One task at a time
  4. Validate continuously: Run tests after each change
  5. Commit incrementally: Small, focused commits with clear messages

Working Principles

  • Follow existing patterns discovered in research
  • Run tests after every meaningful change
  • If something fails, understand why before proceeding
  • Keep changes focused—don't scope creep

Quality Checks During Work

# After each change, verify:
npm run typecheck  # or equivalent
npm test           # run affected tests
npm run lint       # check code quality

Step 3: Review

Before merging, perform comprehensive review:

Review Checklist

Code Quality

  • Follows existing codebase patterns and conventions
  • No unnecessary complexity—prefer duplication over wrong abstraction
  • Clear naming that matches project conventions
  • No debug code or console.logs left behind

Security

  • No secrets or sensitive data exposed
  • Input validation where needed
  • Safe handling of user data

Performance

  • No obvious performance regressions
  • Database queries are efficient (no N+1)
  • Appropriate caching if applicable

Testing

  • Tests cover acceptance criteria
  • Edge cases considered
  • Tests are maintainable, not brittle

Architecture

  • Change is consistent with system design
  • No unnecessary coupling introduced
  • Follows separation of concerns

Multi-Perspective Review

Consider the code from different angles:

  • Maintainer perspective: Will this be easy to modify in 6 months?
  • Performance perspective: Any bottlenecks?
  • Security perspective: Any vulnerabilities?
  • Simplicity perspective: Can this be simpler?

Step 4: Compound

This is where the magic happens—capture learnings to make future work easier:

What to Compound

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]

Where to Codify Learnings

  1. AGENTS.md: Project-wide guidance that applies everywhere
  2. Subdirectory AGENTS.md: Specific guidance for subsystems
  3. Inline comments: Only when the code isn't self-explanatory
  4. Test cases: Turn bugs into regression tests

Compounding in Practice

After completing work, ask:

  • What did I learn that others should know?
  • What mistake did I make that can be prevented?
  • What pattern did I discover or create?
  • What decision was made and why?

Document these in the appropriate location so future agents (and humans) benefit.

Practical Commands

Planning a Feature

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

Executing Work

Execute this plan: [plan reference]
- Create feature branch
- Break into TODO list
- Work through systematically
- Run tests after each change
- Create PR when complete

Reviewing Code

Review this change: [PR/​diff reference]
- Check for code quality issues
- Look for security concerns
- Evaluate performance implications
- Verify test coverage
- Suggest improvements

Compounding Learnings

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

Key Principles

  1. Prefer duplication over wrong abstraction: Simple, clear code beats complex abstractions
  2. Document as you go: Every command generates documentation that makes future work easier
  3. Quality compounds: High-quality code is easier to modify
  4. Systematic beats heroic: Consistent processes beat individual heroics
  5. Knowledge should be codified: Learnings should be captured and reused

Success Metrics

You're doing compound engineering well when:

  • Each feature takes less effort than the last similar feature
  • Bugs become one-time events (documented and prevented)
  • New team members can be productive quickly (institutional knowledge is accessible)
  • Code reviews surface fewer issues (patterns are established and followed)
  • Technical debt decreases over time (learnings compound)

Remember: You're not just building features—you're building a development system that gets better with each use.

More skills from majiayu000

xiaohongshu logo
majiayu000/claude-arsenal

xiaohongshu

xiaohongshu

286 148
View
agent-task-conductor logo
majiayu000/claude-skill-registry

agent-task-conductor

Conduct multi-agent task orchestration and workflow coordination.

663 1
View
conductor-setup logo
majiayu000/claude-skill-registry

conductor-setup

Initialize project with Conductor artifacts (product definition,

663 1
View
animation-designer logo
majiayu000/claude-skill-registry

animation-designer

Expert in web animations, transitions, and motion design using Framer Motion and CSS

663 1
View
diagramming logo
majiayu000/claude-skill-registry

diagramming

Creates Mermaid and ASCII diagrams for flowcharts, architecture, ERDs, state machines, mindmaps, and more. Use when user mentions diagram, flowchart, mermaid, ASCII diagram, text diagram, terminal diagram, visualize, C4, mindmap, architecture diagram, sequence diagram, ERD, or needs visual docume...

663 1
View
h3-pg logo
majiayu000/claude-skill-registry-data

h3-pg

PostgreSQL bindings for H3 hexagonal grid system. Use when working with H3 cells in Postgres, including spatial indexing, geometry/geography integration, and raster analysis.

23 1
View
conductor-development logo
majiayu000/claude-skill-registry

conductor-development

Context-Driven Development skill for projects using Conductor. Use this skill when you detect a `conductor/` directory in the project, when working on tasks defined in a `plan.md` file, or when the user asks about tracks, specs, or plans. Automatically applies TDD workflow, tracks task completion...

663 1
View
conductor-status logo
majiayu000/claude-skill-registry

conductor-status

Display project status, active tracks, and next actions

663 1
View
dockerization logo
majiayu000/claude-skill-registry

dockerization

Official Stakpak application containerization standard operating procedure, a step-by-step guidline to properly dockerize applications. This is a rule book curated by the Stakpak Team.

663 1
View

Popular AI tools

Kaiber logo
Video

Kaiber

Generate, edit, and beat-sync AI video with leading models in one workspace.

Paid
View
Vimcal logo
Productivity

Vimcal

The world's fastest calendar for remote work

Free
View

Transform Your Design with AI Designer by ImgCreator.ai

Freemium
View
Akool AI logo
Content & writing

Akool AI

Revolutionizing Video Production with AI-Powered Creativity

Paid
View

Extend an image past the frame and let AI fill the new aspect ratio.

Freemium
View
StarByFace logo
Security

StarByFace

Discover your celebrity doppelgänger with StarByFace!

Free
View
C

ChainClarity explains 700+ crypto whitepapers in plain English, with layered summaries, comparisons, research tools, alerts, and a $4.99 Pro plan.

Freemium
View
Opus Clip logo
Coding & apps

Opus Clip

Opus.ai: Revolutionize Your Web Experience

Free
View