From b87934c4ebf7ee8399e9c7662ccf2cc4d967102c Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 20 Oct 2025 22:21:36 +0000 Subject: [PATCH 1/3] Add comprehensive README for compounding-engineering plugin MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Create a new README that clearly explains how to use the plugin with focus on the three core commands: /plan, /work, and /review. The README: - Explains the compounding engineering philosophy - Provides clear workflow guidance (Plan → Work → Review) - Includes practical quick start examples - Lists all 17 agents and six commands - Follows Every's style guide conventions This makes it much easier for new users to understand how to use the plugin effectively. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- plugins/compounding-engineering/README.md | 223 ++++++++++++++++++++++ 1 file changed, 223 insertions(+) create mode 100644 plugins/compounding-engineering/README.md diff --git a/plugins/compounding-engineering/README.md b/plugins/compounding-engineering/README.md new file mode 100644 index 0000000..2dc4ccd --- /dev/null +++ b/plugins/compounding-engineering/README.md @@ -0,0 +1,223 @@ +# Compounding Engineering Plugin + +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. + +## What Is Compounding Engineering? + +**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. + +## How It Works + +The plugin follows a three-step workflow that makes development compound: + +### 1. Plan: Turn Ideas Into Structured Issues + +Use `/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. + +### 2. Work: Execute Plans Systematically + +Use `/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. + +### 3. Review: Ensure Quality Before Merging + +Use `/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. + +## Quick Start Guide + +### Install the Plugin + +```bash +# Add the Every marketplace +claude /plugin marketplace add https://github.com/EveryInc/every-marketplace + +# Install the compounding engineering plugin +claude /plugin install compounding-engineering +``` + +### Example: Plan a New Feature + +```bash +# Create a detailed GitHub issue from a feature description +claude /plan "Add user profile avatars with S3 upload and automatic resizing" +``` + +The command will: +1. Research how your codebase handles file uploads +2. Find similar features in your repository +3. Check framework documentation for best practices +4. 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 + +### Example: Execute a Work Plan + +```bash +# Execute a plan document systematically +claude /work path/to/plan.md +``` + +The command will: +1. Create a feature branch and isolated worktree +2. Analyze the plan and create a comprehensive todo list +3. Execute each task systematically +4. Run tests after every change +5. Create a pull request when complete + +### Example: Review a Pull Request + +```bash +# Review the latest PR +claude /review + +# Review a specific PR +claude /review 123 + +# Review from a GitHub URL +claude /review https://github.com/user/repo/pull/123 +``` + +The command will: +1. Check out the PR in an isolated worktree +2. 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 +3. Present findings one by one for triage +4. Create todos for approved findings + +## All Commands + +The plugin includes six commands for different stages of development: + +### `/plan [feature description]` +Creates detailed GitHub issues from feature descriptions. Includes research, acceptance criteria, and implementation guidance. + +### `/work [plan file]` +Executes work plans systematically with worktrees, todos, and continuous validation. + +### `/review [PR number or URL]` +Performs exhaustive multi-agent code reviews with security, performance, and architecture analysis. + +### `/triage` +Presents findings one by one for review and converts approved items into trackable todos. + +### `/resolve_todo_parallel` +Resolves multiple todos in parallel with systematic execution and quality checks. + +### `/generate_command` +Generates new Claude Code commands from descriptions. + +## All Agents + +The plugin includes 17 specialized agents that provide expertise in different areas: + +### Code Review Specialists +- **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 + +### Quality Guardians +- **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 & Patterns +- **architecture-strategist:** System design review and architectural guidance +- **pattern-recognition-specialist:** Identifies patterns and suggests improvements + +### Research & Analysis +- **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 + +### Workflow & Communication +- **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 + +## Why This Makes Development Compound + +Traditional development tools help you work faster. Compounding engineering tools make future work easier. + +**Every `/plan` you create:** +- Documents patterns that inform the next plan +- Establishes conventions that reduce planning time +- Builds institutional knowledge + +**Every `/work` execution:** +- Creates reusable components +- Refines your testing approach +- Improves your development process + +**Every `/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. + +## Philosophy in Practice + +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 `/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. + +## Getting Started + +1. Install the plugin (see Quick Start Guide above) +2. Run `/plan` on your next feature idea +3. Use `/work` to execute the plan +4. Run `/review` before merging +5. Repeat, and watch your development process compound + +Each cycle makes the next cycle easier. That's compounding engineering. \ No newline at end of file From daf3afc997d54fe707b34aa9d836360f6da0a121 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 20 Oct 2025 22:22:58 +0000 Subject: [PATCH 2/3] Update marketplace README with comprehensive plugin documentation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Expand the marketplace README to include the full compounding engineering plugin documentation. This makes it immediately clear to visitors what the plugin does and how to use it. Key additions: - Detailed explanation of the three-step workflow (Plan → Work → Review) - Practical examples for each core command - Complete list of all six commands and 17 agents - Philosophy and benefits of compounding engineering - Clear getting started guide Kept the original installation instructions and added the detailed documentation below, making the marketplace README a comprehensive resource. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- README.md | 235 +++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 216 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 63c4ca7..fa9a621 100644 --- a/README.md +++ b/README.md @@ -2,45 +2,49 @@ The official Every marketplace where engineers from Every.to share their workflows. Currently featuring the Compounding Engineering Philosophy plugin. -## Quick start +## Quick Start ### Standard Installation Run Claude and add the marketplace: -``` +```bash /plugin marketplace add https://github.com/EveryInc/every-marketplace ``` Then install the plugin: -``` +```bash /plugin install compounding-engineering ``` + ### One-Command Installation Use the [Claude Plugins CLI](https://claude-plugins.dev) to skip the marketplace setup: + ```bash npx claude-plugins install @EveryInc/every-marketplace/compounding-engineering ``` This automatically adds the marketplace and installs the plugin in a single step. -## Available plugins +--- -### Compounding engineering +# Compounding Engineering Plugin -AI-powered development tools that get smarter with every use. Includes specialized agents, commands, and five workflows. +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. -**Features:** +## What Is Compounding Engineering? -- Code review with multiple expert perspectives -- Automated testing and bug reproduction -- PR management and parallel comment resolution -- Documentation generation and maintenance -- Security, performance, and architecture analysis +**Each unit of engineering work should make subsequent units of work easier—not harder.** -**Philosophy:** +Traditional development accumulates technical debt. Every feature adds complexity. Every change increases maintenance burden. The codebase becomes harder to work with over time. -Each unit of engineering work makes subsequent units of work easier—not harder. +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. ```mermaid graph LR @@ -55,9 +59,202 @@ graph LR style D fill:#ffb,stroke:#333,stroke-width:2px ``` -1. **Plan** → Break down tasks with clear steps -2. **Delegate** → Execute with AI assistance -3. **Assess** → Test thoroughly and verify quality -4. **Codify** → Record learnings for next time +## How It Works -[Read more](https://every.to/source-code/my-ai-had-already-fixed-the-code-before-i-saw-it) +The plugin follows a three-step workflow that makes development compound: + +### 1. Plan: Turn Ideas Into Structured Issues + +Use `/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. + +### 2. Work: Execute Plans Systematically + +Use `/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. + +### 3. Review: Ensure Quality Before Merging + +Use `/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. + +## Practical Examples + +### Example: Plan a New Feature + +```bash +# Create a detailed GitHub issue from a feature description +claude /plan "Add user profile avatars with S3 upload and automatic resizing" +``` + +The command will: +1. Research how your codebase handles file uploads +2. Find similar features in your repository +3. Check framework documentation for best practices +4. 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 + +### Example: Execute a Work Plan + +```bash +# Execute a plan document systematically +claude /work path/to/plan.md +``` + +The command will: +1. Create a feature branch and isolated worktree +2. Analyze the plan and create a comprehensive todo list +3. Execute each task systematically +4. Run tests after every change +5. Create a pull request when complete + +### Example: Review a Pull Request + +```bash +# Review the latest PR +claude /review + +# Review a specific PR +claude /review 123 + +# Review from a GitHub URL +claude /review https://github.com/user/repo/pull/123 +``` + +The command will: +1. Check out the PR in an isolated worktree +2. 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 +3. Present findings one by one for triage +4. Create todos for approved findings + +## All Commands + +The plugin includes six commands for different stages of development: + +### `/plan [feature description]` +Creates detailed GitHub issues from feature descriptions. Includes research, acceptance criteria, and implementation guidance. + +### `/work [plan file]` +Executes work plans systematically with worktrees, todos, and continuous validation. + +### `/review [PR number or URL]` +Performs exhaustive multi-agent code reviews with security, performance, and architecture analysis. + +### `/triage` +Presents findings one by one for review and converts approved items into trackable todos. + +### `/resolve_todo_parallel` +Resolves multiple todos in parallel with systematic execution and quality checks. + +### `/generate_command` +Generates new Claude Code commands from descriptions. + +## All Agents + +The plugin includes 17 specialized agents that provide expertise in different areas: + +### Code Review Specialists +- **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 + +### Quality Guardians +- **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 & Patterns +- **architecture-strategist:** System design review and architectural guidance +- **pattern-recognition-specialist:** Identifies patterns and suggests improvements + +### Research & Analysis +- **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 + +### Workflow & Communication +- **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 + +## Why This Makes Development Compound + +Traditional development tools help you work faster. Compounding engineering tools make future work easier. + +**Every `/plan` you create:** +- Documents patterns that inform the next plan +- Establishes conventions that reduce planning time +- Builds institutional knowledge + +**Every `/work` execution:** +- Creates reusable components +- Refines your testing approach +- Improves your development process + +**Every `/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. + +## Philosophy in Practice + +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 `/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. + +## Getting Started + +1. Install the plugin using one of the methods above +2. Run `/plan` on your next feature idea +3. Use `/work` to execute the plan +4. Run `/review` before merging +5. Repeat, and watch your development process compound + +Each cycle makes the next cycle easier. That's compounding engineering. + +## Learn More + +[Read the full story](https://every.to/source-code/my-ai-had-already-fixed-the-code-before-i-saw-it) about how compounding engineering transforms development workflows. \ No newline at end of file From 4d6632037a56b699e20665cf8138a0aa622c2321 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 20 Oct 2025 22:32:54 +0000 Subject: [PATCH 3/3] Fix command prefixes and remove plugin README MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two corrections based on feedback: 1. Remove plugin README - only the marketplace README is needed 2. Update all command references to use correct prefix format: - /plan → /compounding-engineering:plan - /work → /compounding-engineering:work - /review → /compounding-engineering:review - All other commands updated similarly This ensures the documentation accurately reflects how users actually invoke the commands. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- README.md | 42 ++-- plugins/compounding-engineering/README.md | 223 ---------------------- 2 files changed, 21 insertions(+), 244 deletions(-) delete mode 100644 plugins/compounding-engineering/README.md diff --git a/README.md b/README.md index fa9a621..3c4eb16 100644 --- a/README.md +++ b/README.md @@ -65,7 +65,7 @@ The plugin follows a three-step workflow that makes development compound: ### 1. Plan: Turn Ideas Into Structured Issues -Use `/plan` to transform feature descriptions into comprehensive GitHub issues. +Use `/compounding-engineering:plan` to transform feature descriptions into comprehensive GitHub issues. **What it does:** - Researches your codebase to find similar patterns and conventions @@ -77,7 +77,7 @@ Use `/plan` to transform feature descriptions into comprehensive GitHub issues. ### 2. Work: Execute Plans Systematically -Use `/work` to execute work plans with isolated worktrees and systematic task tracking. +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 @@ -89,7 +89,7 @@ Use `/work` to execute work plans with isolated worktrees and systematic task tr ### 3. Review: Ensure Quality Before Merging -Use `/review` to perform exhaustive multi-agent code reviews. +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 @@ -105,7 +105,7 @@ Use `/review` to perform exhaustive multi-agent code reviews. ```bash # Create a detailed GitHub issue from a feature description -claude /plan "Add user profile avatars with S3 upload and automatic resizing" +claude /compounding-engineering:plan "Add user profile avatars with S3 upload and automatic resizing" ``` The command will: @@ -123,7 +123,7 @@ You can choose detail levels: ```bash # Execute a plan document systematically -claude /work path/to/plan.md +claude /compounding-engineering:work path/to/plan.md ``` The command will: @@ -137,13 +137,13 @@ The command will: ```bash # Review the latest PR -claude /review +claude /compounding-engineering:review # Review a specific PR -claude /review 123 +claude /compounding-engineering:review 123 # Review from a GitHub URL -claude /review https://github.com/user/repo/pull/123 +claude /compounding-engineering:review https://github.com/user/repo/pull/123 ``` The command will: @@ -161,22 +161,22 @@ The command will: The plugin includes six commands for different stages of development: -### `/plan [feature description]` +### `/compounding-engineering:plan [feature description]` Creates detailed GitHub issues from feature descriptions. Includes research, acceptance criteria, and implementation guidance. -### `/work [plan file]` +### `/compounding-engineering:work [plan file]` Executes work plans systematically with worktrees, todos, and continuous validation. -### `/review [PR number or URL]` +### `/compounding-engineering:review [PR number or URL]` Performs exhaustive multi-agent code reviews with security, performance, and architecture analysis. -### `/triage` +### `/compounding-engineering:triage` Presents findings one by one for review and converts approved items into trackable todos. -### `/resolve_todo_parallel` +### `/compounding-engineering:resolve_todo_parallel` Resolves multiple todos in parallel with systematic execution and quality checks. -### `/generate_command` +### `/compounding-engineering:generate_command` Generates new Claude Code commands from descriptions. ## All Agents @@ -214,17 +214,17 @@ The plugin includes 17 specialized agents that provide expertise in different ar Traditional development tools help you work faster. Compounding engineering tools make future work easier. -**Every `/plan` you create:** +**Every `/compounding-engineering:plan` you create:** - Documents patterns that inform the next plan - Establishes conventions that reduce planning time - Builds institutional knowledge -**Every `/work` execution:** +**Every `/compounding-engineering:work` execution:** - Creates reusable components - Refines your testing approach - Improves your development process -**Every `/review` you run:** +**Every `/compounding-engineering:review` you run:** - Catches issues earlier - Documents learnings for the team - Raises the quality bar systematically @@ -241,16 +241,16 @@ The plugin embodies these compounding engineering principles: **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 `/work` command executes plans systematically, with continuous validation. +**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. ## Getting Started 1. Install the plugin using one of the methods above -2. Run `/plan` on your next feature idea -3. Use `/work` to execute the plan -4. Run `/review` before merging +2. Run `/compounding-engineering:plan` on your next feature idea +3. Use `/compounding-engineering:work` to execute the plan +4. Run `/compounding-engineering:review` before merging 5. Repeat, and watch your development process compound Each cycle makes the next cycle easier. That's compounding engineering. diff --git a/plugins/compounding-engineering/README.md b/plugins/compounding-engineering/README.md deleted file mode 100644 index 2dc4ccd..0000000 --- a/plugins/compounding-engineering/README.md +++ /dev/null @@ -1,223 +0,0 @@ -# Compounding Engineering Plugin - -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. - -## What Is Compounding Engineering? - -**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. - -## How It Works - -The plugin follows a three-step workflow that makes development compound: - -### 1. Plan: Turn Ideas Into Structured Issues - -Use `/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. - -### 2. Work: Execute Plans Systematically - -Use `/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. - -### 3. Review: Ensure Quality Before Merging - -Use `/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. - -## Quick Start Guide - -### Install the Plugin - -```bash -# Add the Every marketplace -claude /plugin marketplace add https://github.com/EveryInc/every-marketplace - -# Install the compounding engineering plugin -claude /plugin install compounding-engineering -``` - -### Example: Plan a New Feature - -```bash -# Create a detailed GitHub issue from a feature description -claude /plan "Add user profile avatars with S3 upload and automatic resizing" -``` - -The command will: -1. Research how your codebase handles file uploads -2. Find similar features in your repository -3. Check framework documentation for best practices -4. 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 - -### Example: Execute a Work Plan - -```bash -# Execute a plan document systematically -claude /work path/to/plan.md -``` - -The command will: -1. Create a feature branch and isolated worktree -2. Analyze the plan and create a comprehensive todo list -3. Execute each task systematically -4. Run tests after every change -5. Create a pull request when complete - -### Example: Review a Pull Request - -```bash -# Review the latest PR -claude /review - -# Review a specific PR -claude /review 123 - -# Review from a GitHub URL -claude /review https://github.com/user/repo/pull/123 -``` - -The command will: -1. Check out the PR in an isolated worktree -2. 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 -3. Present findings one by one for triage -4. Create todos for approved findings - -## All Commands - -The plugin includes six commands for different stages of development: - -### `/plan [feature description]` -Creates detailed GitHub issues from feature descriptions. Includes research, acceptance criteria, and implementation guidance. - -### `/work [plan file]` -Executes work plans systematically with worktrees, todos, and continuous validation. - -### `/review [PR number or URL]` -Performs exhaustive multi-agent code reviews with security, performance, and architecture analysis. - -### `/triage` -Presents findings one by one for review and converts approved items into trackable todos. - -### `/resolve_todo_parallel` -Resolves multiple todos in parallel with systematic execution and quality checks. - -### `/generate_command` -Generates new Claude Code commands from descriptions. - -## All Agents - -The plugin includes 17 specialized agents that provide expertise in different areas: - -### Code Review Specialists -- **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 - -### Quality Guardians -- **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 & Patterns -- **architecture-strategist:** System design review and architectural guidance -- **pattern-recognition-specialist:** Identifies patterns and suggests improvements - -### Research & Analysis -- **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 - -### Workflow & Communication -- **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 - -## Why This Makes Development Compound - -Traditional development tools help you work faster. Compounding engineering tools make future work easier. - -**Every `/plan` you create:** -- Documents patterns that inform the next plan -- Establishes conventions that reduce planning time -- Builds institutional knowledge - -**Every `/work` execution:** -- Creates reusable components -- Refines your testing approach -- Improves your development process - -**Every `/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. - -## Philosophy in Practice - -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 `/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. - -## Getting Started - -1. Install the plugin (see Quick Start Guide above) -2. Run `/plan` on your next feature idea -3. Use `/work` to execute the plan -4. Run `/review` before merging -5. Repeat, and watch your development process compound - -Each cycle makes the next cycle easier. That's compounding engineering. \ No newline at end of file