The official Every marketplace where engineers from Every.to share their workflows. Currently featuring the Compounding Engineering Philosophy plugin.
Run Claude and add the marketplace:
/plugin marketplace add https://github.com/EveryInc/every-marketplaceThen install the plugin:
/plugin install compounding-engineeringUse the Claude Plugins CLI to skip the marketplace setup:
npx claude-plugins install @EveryInc/every-marketplace/compounding-engineeringThis automatically adds the marketplace and installs the plugin in a single step.
A Claude Code plugin that makes each unit of engineering work easier than the last. Transform how you plan, build, and review code using AI-powered tools that systematically improve your development workflow.
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. The codebase becomes harder to work with over time.
Compounding engineering inverts this. Each feature you build:
- Documents patterns for the next feature
- Creates reusable components that accelerate future work
- Establishes conventions that reduce decision fatigue
- Codifies knowledge that compounds across the team
This plugin provides the tools to make compounding engineering practical. It transforms vague ideas into structured plans, executes those plans systematically, and ensures every change meets your quality bar before merging.
graph LR
A[Plan<br/>Plan it out<br/>in detail] --> B[Delegate<br/>Do the work]
B --> C[Assess<br/>Make sure<br/>it works]
C --> D[Codify<br/>Record<br/>learnings]
D --> A
style A fill:#f9f,stroke:#333,stroke-width:2px
style B fill:#bbf,stroke:#333,stroke-width:2px
style C fill:#bfb,stroke:#333,stroke-width:2px
style D fill:#ffb,stroke:#333,stroke-width:2px
The plugin follows a three-step workflow that makes development compound:
Use /compounding-engineering:plan to transform feature descriptions into comprehensive GitHub issues.
What it does:
- Researches your codebase to find similar patterns and conventions
- Analyzes framework documentation and best practices
- Creates detailed acceptance criteria and implementation plans
- Generates code examples that follow your existing patterns
The result: Issues that make implementation easier because they've already done the research and planning work.
Use /compounding-engineering:work to execute work plans with isolated worktrees and systematic task tracking.
What it does:
- Creates isolated git worktrees for clean development
- Breaks down plans into trackable todos
- Executes tasks systematically with continuous validation
- Runs tests and quality checks after each change
The result: Features built correctly the first time, with full test coverage and no regressions.
Use /compounding-engineering:review to perform exhaustive multi-agent code reviews.
What it does:
- Checks out your PR in an isolated worktree for deep analysis
- Runs 12+ specialized review agents in parallel
- Identifies security issues, performance problems, and architectural concerns
- Creates trackable todos for every finding
The result: Code that meets your quality bar and documents learnings for future work.
# Create a detailed GitHub issue from a feature description
claude /compounding-engineering:plan "Add user profile avatars with S3 upload and automatic resizing"The command will:
- Research how your codebase handles file uploads
- Find similar features in your repository
- Check framework documentation for best practices
- Generate a complete issue with acceptance criteria, technical approach, and code examples
You can choose detail levels:
- Minimal: Quick issues for simple features
- More: Standard issues with technical considerations
- A lot: Comprehensive issues for major features
# Execute a plan document systematically
claude /compounding-engineering:work path/to/plan.mdThe command will:
- Create a feature branch and isolated worktree
- Analyze the plan and create a comprehensive todo list
- Execute each task systematically
- Run tests after every change
- Create a pull request when complete
# Review the latest PR
claude /compounding-engineering:review
# Review a specific PR
claude /compounding-engineering:review 123
# Review from a GitHub URL
claude /compounding-engineering:review https://github.com/user/repo/pull/123The command will:
- Check out the PR in an isolated worktree
- Run 12+ specialized review agents in parallel:
- Language-specific reviewers (Rails, TypeScript, Python)
- Security sentinel for vulnerability scanning
- Performance oracle for optimization opportunities
- Architecture strategist for design review
- Data integrity guardian for database concerns
- Present findings one by one for triage
- Create todos for approved findings
The plugin includes six commands for different stages of development:
Creates detailed GitHub issues from feature descriptions. Includes research, acceptance criteria, and implementation guidance.
Executes work plans systematically with worktrees, todos, and continuous validation.
Performs exhaustive multi-agent code reviews with security, performance, and architecture analysis.
Presents findings one by one for review and converts approved items into trackable todos.
Resolves multiple todos in parallel with systematic execution and quality checks.
Generates new Claude Code commands from descriptions.
The plugin includes 17 specialized agents that provide expertise in different areas:
- kieran-rails-reviewer: Strict Rails code review with focus on conventions and simplicity
- kieran-typescript-reviewer: TypeScript code review with type safety and best practices
- kieran-python-reviewer: Python code review with focus on clarity and conventions
- dhh-rails-reviewer: Rails review from DHH's philosophy of simplicity
- code-simplicity-reviewer: Identifies opportunities to simplify complex code
- security-sentinel: Comprehensive security audits and vulnerability detection
- performance-oracle: Performance analysis and optimization recommendations
- data-integrity-guardian: Database design review and data consistency checks
- architecture-strategist: System design review and architectural guidance
- pattern-recognition-specialist: Identifies patterns and suggests improvements
- repo-research-analyst: Analyzes repository patterns and conventions
- best-practices-researcher: Researches best practices for technologies
- framework-docs-researcher: Fetches relevant framework documentation
- git-history-analyzer: Analyzes git history for context and patterns
- every-style-editor: Edits content to match Every's style guide
- feedback-codifier: Converts feedback into actionable improvements
- pr-comment-resolver: Systematically resolves PR review comments
Traditional development tools help you work faster. Compounding engineering tools make future work easier.
Every /compounding-engineering:plan you create:
- Documents patterns that inform the next plan
- Establishes conventions that reduce planning time
- Builds institutional knowledge
Every /compounding-engineering:work execution:
- Creates reusable components
- Refines your testing approach
- Improves your development process
Every /compounding-engineering:review you run:
- Catches issues earlier
- Documents learnings for the team
- Raises the quality bar systematically
Over time, you're not just building features—you're building a development system that gets better with each use.
The plugin embodies these compounding engineering principles:
Prefer duplication over complexity: Simple, clear code that's easy to understand beats complex abstractions. The kieran-rails-reviewer enforces this strictly.
Document as you go: Every command generates documentation—issues, todos, review findings—that makes future work easier.
Quality compounds: High-quality code is easier to modify. The multi-agent review system ensures every change meets your quality bar.
Systematic beats heroic: Consistent processes beat individual heroics. The /compounding-engineering:work command executes plans systematically, with continuous validation.
Knowledge should be codified: Learnings should be captured and reused. The research agents analyze your codebase to apply your own patterns back to you.
- Install the plugin using one of the methods above
- Run
/compounding-engineering:planon your next feature idea - Use
/compounding-engineering:workto execute the plan - Run
/compounding-engineering:reviewbefore merging - Repeat, and watch your development process compound
Each cycle makes the next cycle easier. That's compounding engineering.
Read the full story about how compounding engineering transforms development workflows.
