Getting Started with Compounding Engineering

Installation

Prerequisites

• Claude Code installed and configured
• A GitHub account (for marketplace access)
• Node.js 18+ (for MCP servers)

Step 1: Add the Marketplace

Think of the marketplace as an app store. You're adding it to Claude Code's list of places to look for plugins:

claude /plugin marketplace add https://github.com/EveryInc/every-marketplace

Step 2: Install the Plugin

Now grab the plugin itself:

claude /plugin install compound-engineering

Step 3: Verify Installation

Check that it worked:

claude /plugin list

You'll see compound-engineering in the list. If you do, you're ready.

Quick Start

Let's see what this thing can actually do. I'll show you three workflows you'll use constantly:

Run a Code Review

This is the big one. Type /review and watch it spawn 10+ specialized reviewers:

# Review a PR by number
/review 123

# Review the current branch
/review

# Review a specific branch
/review feature/my-feature

Use a Specialized Agent

Sometimes you just need one expert. Call them directly:

# Rails code review with Kieran's conventions
claude agent kieran-rails-reviewer "Review the UserController"

# Security audit
claude agent security-sentinel "Audit authentication flow"

# Research best practices
claude agent best-practices-researcher "Find pagination patterns for Rails"

Invoke a Skill

Skills are like loading a reference book into Claude's brain. When you need deep knowledge in a specific domain:

# Generate images with Gemini
skill: gemini-imagegen

# Write Ruby in DHH's style
skill: dhh-ruby-style

# Create a new Claude Code skill
skill: create-agent-skills

Configuration

MCP Server Configuration

If the MCP servers didn't load automatically, paste this into .claude/settings.json:

{
  "mcpServers": {
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"],
      "env": {}
    },
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/mcp"
    }
  }
}

Environment Variables

Right now, only one skill needs an API key. If you use Gemini's image generation:

The Compounding Engineering Philosophy

Every unit of engineering work should make subsequent units of work easier—not harder.

Here's how it works in practice—the four-step loop you'll run over and over:

Using Agents

Think of agents as coworkers with different job titles. You wouldn't ask your security engineer to design your UI, right? Same concept here—each agent has a specialty, and you call the one you need.

Invoking Agents

# Basic syntax
claude agent [agent-name] "[optional message]"

# Examples
claude agent kieran-rails-reviewer
claude agent security-sentinel "Audit the payment flow"
claude agent git-history-analyzer "Show changes to user model"

Agent Categories

View All Agents

Using Commands

Commands are macros that run entire workflows for you. One command can spin up a dozen agents, coordinate their work, collect results, and hand you a summary. It's automation all the way down.

Running Commands

# Workflow commands
/plan
/review 123
/work
/compound

# Utility commands
/changelog
/triage
/reproduce-bug

The Review Workflow

Let me show you what happens when you run /review. Here's the sequence:

1. Detection - Figures out what you want reviewed (PR number, branch name, or current changes)
2. Isolation - Spins up a git worktree so the review doesn't mess with your working directory
3. Parallel execution - Launches 10+ agents simultaneously (security, performance, architecture, accessibility...)
4. Synthesis - Sorts findings by severity (P1 = blocks merge, P2 = should fix, P3 = nice-to-have)
5. Persistence - Creates todo files so you don't lose track of issues
6. Summary - Hands you a readable report with action items

View All Commands

Using Skills

Here's the difference: agents are who does the work, skills are what they know. When you invoke a skill, you're loading a reference library into Claude's context—patterns, templates, examples, workflows. It's like handing Claude a technical manual.

Invoking Skills

# In your prompt, reference the skill
skill: gemini-imagegen

# Or ask Claude to use it
"Use the dhh-ruby-style skill to refactor this code"

Skill Structure

Peek inside a skill directory and you'll usually find:

• SKILL.md - The main instructions (what Claude reads first)
• references/ - Deep dives on concepts and patterns
• templates/ - Copy-paste code snippets
• workflows/ - Step-by-step "how to" guides
• scripts/ - Actual executable code (when words aren't enough)

View All Skills

Code Review Workflow Guide

You'll spend most of your time here. This workflow is why the plugin exists—to turn code review from a bottleneck into a superpower.

Basic Review

# Review a PR
/review 123

# Review current branch
/review

Understanding Findings

Every finding gets a priority label. Here's what they mean:

• P1 Critical - Don't merge until this is fixed. Think: SQL injection, data loss, crashes in production.
• P2 Important - Fix before shipping. Performance regressions, N+1 queries, shaky architecture.
• P3 Nice-to-Have - Would be better, but ship without it if you need to. Documentation, minor cleanup, style issues.

Working with Todo Files

After a review, you'll have a todos/ directory full of markdown files. Each one is a single issue to fix:

# List all pending todos
ls todos/*-pending-*.md

# Triage findings
/triage

# Resolve todos in parallel
/resolve_todo_parallel

Creating Custom Agents

The built-in agents cover a lot of ground, but every team has unique needs. Maybe you want a "rails-api-reviewer" that enforces your company's API standards. That's 10 minutes of work.

Agent File Structure

---
name: my-custom-agent
description: Brief description of what this agent does
---

# Agent Instructions

You are [role description].

## Your Responsibilities
1. First responsibility
2. Second responsibility

## Guidelines
- Guideline one
- Guideline two

Agent Location

Drop your agent file in one of these directories:

• .claude/agents/ - Just for this project (committed to git)
• ~/.claude/agents/ - Available in all your projects (stays on your machine)

Creating Custom Skills

Skills are heavier than agents—they're knowledge bases, not just prompts. You're building a mini library that Claude can reference. Worth the effort for things you do repeatedly.

Skill Directory Structure

my-skill/
  SKILL.md           # Main skill file (required)
  references/        # Supporting documentation
    concept-one.md
    concept-two.md
  templates/         # Code templates
    basic-template.md
  workflows/         # Step-by-step procedures
    workflow-one.md
  scripts/           # Executable scripts
    helper.py

SKILL.md Format

---
name: my-skill
description: Brief description shown when skill is invoked
---

# Skill Title

Detailed instructions for using this skill.

## Quick Start
...

## Reference Materials
The skill includes references in the `references/` directory.

## Templates
Use templates from the `templates/` directory.