AI-powered development tools that compound with every use.
A Claude Code plugin marketplace that turns your AI coding assistant into a full engineering team — with specialized agents for code review, research, design, security, and workflow automation. Each cycle of work makes the next one easier.
Fork of EveryInc/compound-engineering-plugin, extended with safety hooks, spec-driven development, and multi-agent orchestration.
# In Claude Code
/plugin marketplace add https://github.com/kavanaghpatrick/ralph-compounder
/plugin install ralph-compounderThat's it. You now have 29 agents, 24 commands, 18 skills, and 1 MCP server.
Ralph Compounder builds on the original Compound Engineering plugin with several key additions:
| Feature | Original | Ralph Compounder |
|---|---|---|
| Safety hooks | None | PreToolUse hooks block destructive ops |
| Secret protection | None | Auto-prompts before editing .env, .pem, .key files |
| jq injection safety | Vulnerable to shell injection | All hooks use --arg for safe variable passing |
| Spec-driven dev | Manual planning | Ralph Specum: research -> requirements -> design -> tasks -> execute |
| Multi-agent specs | Single-agent | Foreman Spec: 4 specialized AI agents (PM, UX, Tech, QA) |
| CLI tool | None | Convert plugins to OpenCode + Codex formats |
| Test coverage | None | 67 tests across 10 test files (hook validation, CLI, parsing) |
| GitHub org | EveryInc | kavanaghpatrick (independent fork) |
Two PreToolUse hooks that act as guardrails:
validate-bash.sh — Catches destructive shell commands before they run:
git push --force/git reset --hard— prompts for confirmationrm -rf //rm -rf ~/rm -rf .— hard blocked (denied)rm -rf node_modules/.cache/tmp— silently allowed (safe targets)- All other
rm -rf— prompts for confirmation
protect-env-files.sh — Prompts before editing sensitive files:
.env,.env.local,.env.productionetc..pemcertificates and.keyfiles- Files with
credentialsin the name secret.json,secret.yml,secrets.yamletc.
Plan --> Work --> Review --> Compound --> Repeat
80% 20% ^^^ ^^^
multi-agent knowledge
parallel captured
Each cycle compounds: plans inform future plans, reviews catch more issues, patterns get documented. The ratio is intentional — 80% planning and review, 20% execution.
| Command | What it does |
|---|---|
/workflows:plan |
Turn feature ideas into detailed implementation plans |
/workflows:work |
Execute plans with worktrees, task tracking, and PR lifecycle |
/workflows:review |
Multi-agent code review (15 specialized reviewers in parallel) |
/workflows:compound |
Document solved problems so future work gets easier |
/workflows:brainstorm |
Explore requirements and approaches before committing to a plan |
| Command | What it does |
|---|---|
/lfg |
Full autonomous workflow: plan -> work -> review -> ship |
/slfg |
Same as /lfg but with swarm mode — parallel agent execution |
/deepen-plan |
Enhance any plan with parallel research agents per section |
/technical_review |
Multi-agent architecture and security review |
/test-browser |
Automated browser testing on PR-affected pages |
Agents are organized by specialty. Use them individually or let the workflow commands orchestrate them.
| Agent | Focus |
|---|---|
kieran-rails-reviewer |
Rails code review with strict conventions |
kieran-python-reviewer |
Python review with strict conventions |
kieran-typescript-reviewer |
TypeScript 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 |
code-simplicity-reviewer |
Final pass for simplicity and minimalism |
data-integrity-guardian |
Database migrations and data integrity |
data-migration-expert |
Validate ID mappings match production |
deployment-verification-agent |
Go/No-Go deployment checklists |
schema-drift-detector |
Detect unrelated schema.rb changes |
pattern-recognition-specialist |
Code patterns and anti-patterns |
agent-native-reviewer |
Verify features are agent-native |
julik-frontend-races-reviewer |
JavaScript/Stimulus race conditions |
| Agent | Focus |
|---|---|
best-practices-researcher |
External best practices and examples |
framework-docs-researcher |
Framework documentation deep-dives |
git-history-analyzer |
Git history and code evolution |
learnings-researcher |
Institutional knowledge from past solutions |
repo-research-analyst |
Repository structure and conventions |
| Agent | Focus |
|---|---|
figma-design-sync |
Synchronize implementations with Figma designs |
design-iterator |
Iterative UI refinement |
design-implementation-reviewer |
Verify UI matches designs |
| Agent | Focus |
|---|---|
bug-reproduction-validator |
Systematically reproduce bug reports |
pr-comment-resolver |
Address PR comments and implement fixes |
spec-flow-analyzer |
Analyze user flows and identify gaps |
every-style-editor |
Content editing to style guide |
lint |
Ruby and ERB linting |
| Agent | Focus |
|---|---|
ankane-readme-writer |
READMEs following Ankane's gem template |
Skills provide deep domain expertise that Claude can apply during any task.
| Skill | Description |
|---|---|
agent-native-architecture |
Build AI agents using prompt-native patterns |
dhh-rails-style |
Ruby/Rails in DHH's 37signals style |
andrew-kane-gem-writer |
Ruby gems following Andrew Kane's patterns |
dspy-ruby |
Type-safe LLM applications with DSPy.rb |
frontend-design |
Production-grade frontend interfaces |
create-agent-skills |
Expert guidance for creating Claude Code skills |
skill-creator |
Skill creation workflow with validation |
| Skill | Description |
|---|---|
compound-docs |
Capture solved problems as categorized docs |
brainstorming |
Collaborative requirement exploration |
document-review |
Structured self-review for documents |
every-style-editor |
Style guide compliance checking |
file-todos |
File-based todo tracking |
git-worktree |
Parallel development with worktrees |
| Skill | Description |
|---|---|
orchestrating-swarms |
Multi-agent swarm coordination |
agent-browser |
CLI browser automation (Vercel agent-browser) |
gemini-imagegen |
Image generation/editing via Gemini API |
rclone |
Upload to S3, Cloudflare R2, B2 |
resolve-pr-parallel |
Parallel PR comment resolution |
| Server | Description |
|---|---|
context7 |
Documentation lookup for 100+ frameworks (Rails, React, Next.js, Vue, Django, Laravel, etc.) |
Starts automatically when the plugin is enabled. Provides resolve-library-id and get-library-docs tools.
Ralph Compounder includes a Bun/TypeScript CLI that converts Claude Code plugins into other agent formats.
# Convert to OpenCode format
bunx @kavanaghpatrick/ralph-compounder install ralph-compounder --to opencode
# Convert to Codex format
bunx @kavanaghpatrick/ralph-compounder install ralph-compounder --to codex
# Both at once
bunx @kavanaghpatrick/ralph-compounder install ralph-compounder --to opencode --also codex# Sync your ~/.claude/ skills and MCP servers to OpenCode
bunx @kavanaghpatrick/ralph-compounder sync --target opencode
# Sync to Codex
bunx @kavanaghpatrick/ralph-compounder sync --target codexSkills are symlinked (not copied) so changes in Claude Code reflect immediately.
Each unit of engineering work should make subsequent units easier — not harder.
Traditional development accumulates technical debt. Every feature adds complexity. The codebase gets harder to work with over time.
Compound engineering inverts this:
- Plan thoroughly before writing code
- Review with multiple specialists to catch issues early
- Document learnings so they're reusable (
/workflows:compound) - Keep quality high so future changes are easy
The name "Compounder" comes from this compounding effect — each cycle of Plan -> Work -> Review -> Compound makes the next cycle faster and higher quality.
ralph-compounder/
├── .claude-plugin/
│ └── marketplace.json # Marketplace catalog
├── plugins/
│ ├── ralph-compounder/ # Main plugin (29 agents, 24 commands, 18 skills)
│ │ ├── agents/ # review/, research/, design/, workflow/, docs/
│ │ ├── commands/ # Slash commands + workflows/
│ │ ├── skills/ # 18 skill directories
│ │ ├── hooks/ # Safety hooks (validate-bash, protect-env)
│ │ └── .claude-plugin/ # Plugin metadata
│ └── coding-tutor/ # Coding tutorial plugin
├── src/ # CLI tool (Bun/TypeScript)
│ ├── commands/ # install, convert, sync, list
│ ├── targets/ # opencode, codex writers
│ └── utils/ # Parsing, frontmatter, permissions
├── tests/ # 67 tests across 10 files
└── docs/ # Documentation site (GitHub Pages)
# Run tests
bun test
# Local dev
bun run src/index.ts install ./plugins/ralph-compounder --to opencode
# Validate configs
jq . .claude-plugin/marketplace.json
jq . plugins/ralph-compounder/.claude-plugin/plugin.json- Full component reference — all agents, commands, skills in detail
- Compound engineering: how Every codes with agents
- The story behind compounding engineering
MIT