Compound Engineering Plugin

Project Overview

The Compound Engineering Plugin is a Claude Code plugin from Every that implements a systematic workflow for AI-assisted development.^[1] The core philosophy: each unit of engineering work should make subsequent units easier — not harder.

Created by Dan Shipper and Kieran Klaassen at Every, the plugin packages the exact workflow they use to run five products (Cora, Monologue, Sparkle, Spiral, and Every.to) with primarily single-person engineering teams.^[2]

With 9,300+ GitHub stars and active development, it's become one of the most popular Claude Code plugins for teams wanting structured AI workflows rather than ad-hoc prompting.

The Philosophy

Traditional development accumulates technical debt. Each feature adds complexity. After years, teams spend more time fighting their system than building on it.^[2]

Compound engineering inverts this:

• Features teach the system new capabilities instead of adding complexity
• Bug fixes eliminate entire categories of future bugs when patterns are captured
• Knowledge compounds so the codebase becomes easier to work with over time

The key ratio: 80% planning and review, 20% execution. Most thinking happens before and after code gets written — the opposite of how most developers work.

The Main Loop

Plan → Work → Review → Compound → Repeat

The first three steps are familiar. The fourth step — Compound — is where gains accumulate. Skip it, and you've done traditional engineering with AI assistance.^[2]

1. Plan

Transform an idea into a blueprint:

• Understand the requirement (what, why, constraints)
• Research the codebase (existing patterns, similar functionality)
• Research externally (framework docs, best practices)
• Design the solution (approach, affected files)
• Validate the plan (completeness check)

The /workflows:plan command spawns three parallel research agents — repo analysis, framework docs, and best practices — then merges results into a structured plan.

2. Work

Execution follows the plan:

• Set up isolation (git worktrees keep work separate)
• Execute the plan step by step
• Run validations after each change
• Track progress and handle issues

The /workflows:work command creates worktrees, implements tasks, and optionally spawns quality-check agents.

3. Review

Multi-agent code review catches issues and captures learnings:

• 14 specialized agents review in parallel
• Findings prioritized as P1 (must fix), P2 (should fix), P3 (nice to fix)
• Agent fixes issues based on feedback
• Patterns captured for future prevention

The /workflows:review command is the standout feature — 14 specialized reviewers running simultaneously.

4. Compound (The Key Step)

This is what separates compound engineering from traditional AI-assisted dev:

• Capture the solution — What worked? What didn't? What's reusable?
• Make it findable — Tag with metadata for future retrieval
• Update the system — Add patterns to CLAUDE.md, create new agents
• Verify the learning — Would the system catch this automatically next time?

What's in the Box

The plugin ships with:^[1]

26 Specialized Agents:

• 14 code review specialists
• Research agents (codebase, documents)
• Design agents (UI, Figma sync)
• Workflow automation agents
• Documentation agents

23 Workflow Commands:

• /workflows:brainstorm — Clarify fuzzy requirements
• /workflows:plan — Generate implementation blueprints
• /workflows:work — Execute with progress tracking
• /workflows:review — Multi-agent code review
• /workflows:compound — Capture learnings

13 Skills:

• Agent-native architecture patterns
• Style guide enforcement
• Domain expertise on tap

Review Agents Deep Dive

The /workflows:review command spawns 14 agents in parallel:^[2]

Category	Agent	Focus
Security	security-sentinel	OWASP top 10, injection, auth flaws
Performance	performance-oracle	N+1 queries, missing indexes, caching
Architecture	architecture-strategist	System design, component boundaries
Architecture	pattern-recognition-specialist	Design patterns, anti-patterns, smells
Data	data-integrity-guardian	Migrations, transactions, referential integrity
Data	data-migration-expert	ID mappings, rollback safety
Quality	code-simplicity-reviewer	YAGNI, complexity, readability
Quality	kieran-rails-reviewer	Rails conventions, Turbo Streams
Quality	kieran-python-reviewer	PEP 8, type hints, idioms
Quality	kieran-typescript-reviewer	Type safety, ES patterns
Quality	dhh-rails-reviewer	37signals conventions, simplicity
Deployment	deployment-verification-agent	Pre/post deploy checklists, rollback
Frontend	julik-frontend-races-reviewer	JS race conditions, Stimulus
Agent-native	agent-native-reviewer	AI accessibility patterns

Installation

Claude Code (native):

/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin
/plugin install compound-engineering

Codex (experimental):

bunx @every-env/compound-plugin install compound-engineering --to codex

OpenCode (experimental):

bunx @every-env/compound-plugin install compound-engineering --to opencode

Also supports Gemini CLI, GitHub Copilot, Factory Droid, Pi, and Kiro CLI.

File Structure

After installation, projects get:^[2]

your-project/
├── CLAUDE.md           # Agent instructions, preferences, patterns
├── docs/
│   ├── brainstorms/    # /workflows:brainstorm output
│   ├── solutions/      # /workflows:compound output
│   └── plans/          # /workflows:plan output
└── todos/              # Review findings with priority/status
    ├── 001-ready-p1-fix-auth.md
    └── 002-pending-p2-add-tests.md

CLAUDE.md is the most important file — the agent reads it every session. Put preferences, patterns, and project context here. When something goes wrong, add a note so the agent learns.

docs/solutions/ builds institutional knowledge. Each solved problem becomes searchable documentation.

Strengths

• Systematic workflow — Structure beats ad-hoc prompting for complex projects
• Multi-agent review — 14 specialists catch more than one generalist
• Knowledge capture — The Compound step prevents repeated mistakes
• Cross-platform — Works across major AI coding tools
• Battle-tested — Used internally at Every to run five products
• Open source — MIT licensed, full visibility into agents and prompts

Weaknesses / Considerations

• Overhead for small tasks — The full loop is overkill for quick fixes
• Claude Code first — Other platform support is experimental
• Learning curve — The 80/20 ratio feels slow until it clicks
• Token usage — 14 parallel review agents consume significant context
• Opinionated — Assumes you want Every's workflow, not your own

Who Built It

Every is Dan Shipper's company focused on AI-augmented productivity. They run:

• Cora — AI computer assistant
• Monologue — Voice journaling
• Sparkle — AI writing tool
• Spiral — Writing assistant
• Every.to — Newsletter/publication

The compound engineering system emerged from running all five products with small teams. Kieran Klaassen is the primary engineer behind the plugin implementation.

Ideal User

• Solo developers or small teams managing complex codebases
• Claude Code power users wanting more structure
• Teams tired of repeated mistakes who want knowledge capture
• Developers who value planning over "just start coding"
• Anyone experimenting with multi-agent workflows

Bottom Line

The Compound Engineering Plugin represents a mature philosophy for AI-assisted development. The core insight — that each unit of work should make future work easier — is simple but rarely implemented systematically.

The 80/20 ratio (planning/review vs. execution) feels counterintuitive to developers trained to "just start coding," but Every's results running five products with small teams suggest it works.

The 14-agent parallel review is the technical standout. Most AI coding tools review with one model in one pass. Compound Engineering throws specialized agents at security, performance, architecture, and style simultaneously — catching more issues by construction.

For teams ready to invest in systematic AI workflows rather than ad-hoc prompting, this is the most complete open-source option available.

---