# 1578 Compound Engineering Plugin 363b0b77 > Compound Engineering Plugin - AI-Powered Development Workflow - Skill: `tools-only/1578-compound-engineering-plugin-363b0b77` (Agent Skill, multi-file: 3 files) - Install (CLI): `npx skillmds@latest add tools-only/1578-compound-engineering-plugin-363b0b77` - Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/1578-compound-engineering-plugin-363b0b77/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Productivity - Author: tools-only (https://skillmd.com/u/tools-only) - Updated: 2026-09-22 - Page: https://skillmd.com/skills/tools-only/1578-compound-engineering-plugin-363b0b77 --- # Compound Engineering Plugin - AI-Powered Development Workflow **Research Date**: January 31, 2026 **Source URL**: **npm Package**: **Documentation**: **Version at Research**: v2.28.0 **License**: MIT --- ## Overview The Compound Engineering Plugin is a Claude Code plugin marketplace featuring a comprehensive collection of AI agents, commands, and skills designed to make each unit of engineering work easier than the last. Developed by Every Inc., it implements a "compounding engineering" philosophy where planning and review comprise 80% of the workflow, with execution at 20%. **Core Value Proposition**: Invert the traditional development cycle where features accumulate technical debt. Instead, each development cycle documents learnings, improves patterns, and makes future work easier. --- ## Problem Addressed | Problem | How Compound Engineering Solves It | | ------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | | Development work accumulates technical debt over time | Compounding cycle documents solutions and patterns for reuse | | Code reviews catch issues too late in the development cycle | 14 specialized review agents run in parallel before code is merged | | Knowledge silos form when only one developer knows a solution | `/workflows:compound` command captures solutions in searchable `docs/solutions/` | | Planning is often rushed, leading to rework | `/workflows:plan` includes research decision logic and Q&A refinement | | Inconsistent code review quality across team members | Multi-agent review with domain specialists (security, performance, architecture) | | Context loss when switching between tasks | Git worktree integration for parallel development without context switching | | External framework documentation changes faster than team knowledge | Context7 MCP server provides real-time framework documentation lookup (100+ frameworks) | --- ## Key Statistics (as of January 31, 2026) | Metric | Value | | ------------------- | ---------- | | GitHub Stars | 6,830 | | Forks | 546 | | Open Issues | 48 | | Primary Language | TypeScript | | Agents | 27 | | Commands | 20 | | Skills | 14 | | MCP Servers | 1 | | Contributors | 10+ | | npm Package Version | 0.1.1 | --- ## Core Workflow ```text Plan --> Work --> Review --> Compound --> Repeat | | | | v v v v 80% 20% 80% Knowledge Planning Execution Review Compounding ``` | Command | Purpose | | ----------------------- | ----------------------------------------------------- | | `/workflows:brainstorm` | Explore requirements and approaches before planning | | `/workflows:plan` | Turn feature ideas into detailed implementation plans | | `/workflows:work` | Execute plans with worktrees and task tracking | | `/workflows:review` | Multi-agent code review before merging | | `/workflows:compound` | Document learnings to make future work easier | --- ## Key Features ### 1. Multi-Agent Review System 14 specialized review agents run in parallel: **Review Agents:** - `kieran-rails-reviewer` - Rails code review with strict conventions - `kieran-python-reviewer` - Python code review with strict conventions - `kieran-typescript-reviewer` - TypeScript code review with strict conventions - `dhh-rails-reviewer` - Rails review from DHH's perspective - `security-sentinel` - Security audits and vulnerability assessments - `performance-oracle` - Performance analysis and optimization - `architecture-strategist` - Architectural decisions and compliance - `pattern-recognition-specialist` - Code patterns and anti-patterns - `data-integrity-guardian` - Database migrations and data integrity - `agent-native-reviewer` - Verify features are agent-native (action + context parity) - `code-simplicity-reviewer` - Final pass for simplicity and minimalism - `data-migration-expert` - Validate ID mappings match production - `deployment-verification-agent` - Go/No-Go deployment checklists - `julik-frontend-races-reviewer` - JavaScript/Stimulus race conditions ### 2. Research Agents 4 agents for gathering context and best practices: - `best-practices-researcher` - Gather external best practices and examples - `framework-docs-researcher` - Research framework documentation - `git-history-analyzer` - Analyze git history and code evolution - `repo-research-analyst` - Research repository structure and conventions ### 3. Design Agents 3 agents for UI/UX implementation: - `design-implementation-reviewer` - Verify UI matches Figma designs - `design-iterator` - Iteratively refine UI through systematic iterations - `figma-design-sync` - Synchronize web implementations with Figma designs ### 4. Smart Planning with Research Decision Logic The `/workflows:plan` command includes intelligent research decisions: - **High-risk topics** (security, payments, external APIs) always trigger external research - **Strong local context** (good patterns, CLAUDE.md guidance) skips external research - **Uncertainty or unfamiliar territory** triggers external perspective - Interactive Q&A refinement phase with targeted questions ### 5. Knowledge Compounding The `/workflows:compound` command uses 7 parallel subagents: 1. **Context Analyzer** - Extracts problem type, symptoms, YAML frontmatter 2. **Solution Extractor** - Identifies root cause and working solution 3. **Related Docs Finder** - Cross-references existing documentation 4. **Prevention Strategist** - Develops prevention strategies 5. **Category Classifier** - Determines optimal `docs/solutions/` category 6. **Documentation Writer** - Assembles complete markdown file 7. **Specialized Agent Invocation** - Post-documentation expert review ### 6. Utility Commands | Command | Purpose | | ---------------------- | --------------------------------------------- | | `/deepen-plan` | Enhance plans with parallel research agents | | `/changelog` | Create engaging changelogs for recent merges | | `/create-agent-skill` | Create or edit Claude Code skills | | `/heal-skill` | Fix skill documentation issues | | `/plan_review` | Multi-agent plan review in parallel | | `/reproduce-bug` | Reproduce bugs using logs and console | | `/resolve_parallel` | Resolve TODO comments in parallel | | `/resolve_pr_parallel` | Resolve PR comments in parallel | | `/test-browser` | Run browser tests on PR-affected pages | | `/xcode-test` | Build and test iOS apps on simulator | | `/feature-video` | Record video walkthroughs for PR descriptions | ### 7. Skills Library 14 skills for specialized tasks: | Skill | Purpose | | --------------------------- | ------------------------------------------------ | | `agent-native-architecture` | Build AI agents using prompt-native architecture | | `andrew-kane-gem-writer` | Write Ruby gems following Andrew Kane's patterns | | `compound-docs` | Capture solved problems as documentation | | `create-agent-skills` | Expert guidance for creating Claude Code skills | | `dhh-rails-style` | Write Ruby/Rails code in DHH's 37signals style | | `dspy-ruby` | Build type-safe LLM applications with DSPy.rb | | `frontend-design` | Create production-grade frontend interfaces | | `every-style-editor` | Review copy for Every's style guide compliance | | `file-todos` | File-based todo tracking system | | `git-worktree` | Manage Git worktrees for parallel development | | `rclone` | Upload files to S3, Cloudflare R2, Backblaze B2 | | `agent-browser` | CLI-based browser automation via agent-browser | | `gemini-imagegen` | Generate and edit images using Gemini API | | `brainstorming` | Guided ideation before planning | ### 8. MCP Server Integration **Context7** - Framework documentation lookup: - `resolve-library-id` - Find library ID for a framework/package - `get-library-docs` - Get documentation for a specific library - Supports 100+ frameworks (Rails, React, Next.js, Vue, Django, Laravel, etc.) --- ## Technical Architecture ```text ┌─────────────────────────────────────────────────────────────────────┐ │ Compound Engineering Plugin │ ├─────────────────────────────────────────────────────────────────────┤ │ Marketplace Layer (.claude-plugin/marketplace.json) │ │ └── Plugin distribution, version management │ ├─────────────────────────────────────────────────────────────────────┤ │ Plugin Core (plugins/compound-engineering/) │ │ ├── agents/ 27 specialized AI agents │ │ ├── commands/ 20 slash commands (5 workflow + 15 utility) │ │ ├── skills/ 14 skill packages with SKILL.md + scripts │ │ └── mcp-servers/ Context7 framework docs server │ ├─────────────────────────────────────────────────────────────────────┤ │ CLI Converter (src/) │ │ ├── Bun/TypeScript CLI │ │ ├── Converts plugins to OpenCode format │ │ └── Converts plugins to Codex format (experimental) │ ├─────────────────────────────────────────────────────────────────────┤ │ Documentation Site (docs/) │ │ └── Static HTML/CSS/JS (LaunchKit-based, no build step) │ └─────────────────────────────────────────────────────────────────────┘ ``` ### Multi-Platform Support ```bash # Claude Code (native) /plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin /plugin install compound-engineering # OpenCode (experimental) bunx @every-env/compound-plugin install compound-engineering --to opencode # Codex (experimental) bunx @every-env/compound-plugin install compound-engineering --to codex ``` --- ## Installation & Usage ### Basic Installation ```bash # Add marketplace /plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin # Install plugin /plugin install compound-engineering ``` ### Workflow Example ```bash # 1. Plan a feature /workflows:plan Add user authentication with OAuth2 # 2. Execute the plan /workflows:work # 3. Review before merge /workflows:review PR-123 # 4. Document learnings /workflows:compound ``` ### MCP Server Setup (if not auto-loading) ```json { "mcpServers": { "context7": { "type": "http", "url": "https://mcp.context7.com/mcp" } } } ``` --- ## Relevance to Claude Code Development ### Direct Applications 1. **Plugin Architecture Reference**: The plugin structure (agents/, commands/, skills/, mcp-servers/) demonstrates best practices for Claude Code plugin development 2. **Multi-Agent Orchestration**: The parallel agent execution pattern in `/workflows:review` shows effective orchestration strategies 3. **Knowledge Management**: The `docs/solutions/` pattern with YAML frontmatter provides a reusable knowledge base architecture 4. **Cross-Platform Conversion**: The CLI tool for converting plugins to OpenCode/Codex demonstrates portable skill formats ### Patterns Worth Adopting 1. **80/20 Planning-Execution Split**: Heavy investment in planning and review, minimal execution time 2. **Parallel Agent Execution**: Run 14 review agents simultaneously for comprehensive coverage 3. **Smart Research Decision Logic**: Context-aware research triggering based on risk and familiarity 4. **Compound Documentation**: Structured `docs/solutions/` with YAML frontmatter for searchability 5. **Worktree Integration**: Git worktrees for parallel development without context switching 6. **Category-Based Agent Organization**: Agents grouped by domain (Review, Research, Design, Workflow, Docs) 7. **Interactive Q&A Refinement**: Iterative clarification before plan generation ### Integration Opportunities 1. **Agent Patterns**: Review and research agent implementations could inform custom agent development 2. **Skill Templates**: The `create-agent-skills` and `skill-creator` skills provide guidance for skill authoring 3. **MCP Server Model**: Context7 integration demonstrates MCP server bundling in plugins 4. **Documentation Patterns**: The `compound-docs` skill shows structured knowledge capture 5. **Workflow Commands**: The `workflows:` namespace pattern avoids collisions with built-in commands --- ## References 1. **GitHub Repository**: (accessed 2026-01-31) 2. **npm Package**: (accessed 2026-01-31) 3. **Documentation Site**: (accessed 2026-01-31) 4. **Compound Engineering Philosophy**: (accessed 2026-01-31) 5. **Story Behind Compound Engineering**: (accessed 2026-01-31) 6. **Plugin README**: (accessed 2026-01-31) 7. **CHANGELOG**: (accessed 2026-01-31) --- ## Freshness Tracking | Field | Value | | ---------------------------- | --------------------- | | Last Verified | 2026-01-31 | | Version at Verification | v2.28.0 | | GitHub Stars at Verification | 6,830 | | Next Review Recommended | 2026-04-30 (3 months) | **Change Detection Indicators**: - Monitor GitHub releases for version changes (currently v2.28.0) - Check CHANGELOG.md for new agents, commands, or skills - Review npm package updates (@every-env/compound-plugin) - Watch for new workflow patterns in the `/workflows:` namespace - Track growth metrics (stars approaching 7K milestone)