Skip to main content

​
Skills

The Compound Engineering plugin includes 20 specialized skills organized by domain. Skills provide deep, focused expertise that Claude can reference when working on related tasks.

​
What Are Skills?

Skills are structured knowledge documents that Claude loads when a task matches their domain. They contain:
  • Domain-specific instructions and patterns
  • Reference documentation and examples
  • Workflows and checklists
  • Scripts and templates
  • Best practices and anti-patterns
Skills activate automatically when Claude recognizes a relevant task. You can also load them explicitly. Loading a skill manually: 
Load the dhh-rails-style skill and apply it to this controller code.
Skills in commands: Commands often load skills automatically. For example, /ce:brainstorm loads the brainstorming skill for question techniques and approach exploration patterns.

​
Architecture & Design

Skills for building AI-first, agent-native systems.
SkillDescriptionWhen It Activates
agent-native-architectureBuild AI agents using prompt-native architectureBuilding tools for AI agents, MCP servers, agent features
Prompt-native (or agent-native) architecture means designing systems where:
  • Action parity: AI agents can do everything humans can via tools/APIs
  • Context parity: AI agents have access to the same information humans do
  • Self-modification: Systems can be improved by the agents using them
The agent-native-architecture skill includes references on:
  • MCP tool design
  • System prompt patterns
  • Dynamic context injection
  • Files as universal interfaces
  • Agent execution patterns
  • Testing agent-native features
See agent-native-architecture/SKILL.md for full details.

​
Development Tools

Skills for writing high-quality code following specific patterns and frameworks.
SkillDescriptionWhen It Activates
andrew-kane-gem-writerWrite Ruby gems following Andrew Kane’s patternsCreating Ruby gems, writing gem documentation
compound-docsCapture solved problems as categorized documentationRunning /ce:compound command
create-agent-skillsExpert guidance for creating Claude Code skillsCreating or editing skills, running /create-agent-skill
dhh-rails-styleWrite Ruby/Rails code in DHH’s 37signals styleRails development, reviewing Rails code
dspy-rubyBuild type-safe LLM applications with DSPy.rbBuilding LLM-powered features in Ruby
frontend-designCreate production-grade frontend interfacesFrontend development, UI implementation
skill-creatorGuide for creating effective Claude Code skillsCreating new skills, skill structure questions
The dhh-rails-style skill enforces 37signals/Rails core team conventions:Architecture:
  • Majestic Monolith over microservices
  • Hotwire (Turbo + Stimulus) over React/Vue
  • Active Record over repository pattern
Code Style:
  • Simplicity over abstraction
  • Convention over configuration
  • Integrated over isolated
References included:
  • architecture.md - System design patterns
  • controllers.md - RESTful controller conventions
  • models.md - Active Record patterns
  • frontend.md - Hotwire/Stimulus patterns
  • testing.md - Testing philosophy
  • gems.md - Preferred gem choices
See dhh-rails-style/SKILL.md for complete reference.
The andrew-kane-gem-writer skill is perfect for creating Ruby gems that:
  • Provide adapters for multiple databases/services
  • Need clean, minimal APIs
  • Follow Rails integration patterns
  • Have comprehensive test coverage
Patterns included:
  • Module organization for extensibility
  • Database adapter patterns (Postgres, MySQL, SQLite)
  • Rails integration (generators, initializers)
  • Testing patterns for multiple adapters
  • README structure and documentation style
Examples: gems like pgvector, neighbor, searchkick follow these patterns.

​
Content & Workflow

Skills for documentation, planning, and collaborative workflows.
SkillDescriptionWhen It Activates
brainstormingExplore requirements and approaches through collaborative dialogueRunning /ce:brainstorm command
document-reviewImprove documents through structured self-reviewReviewing plans, documentation, brainstorms
every-style-editorReview copy for Every’s style guide complianceEditing content for Every publications
file-todosFile-based todo tracking systemManaging todos across files
git-worktreeManage Git worktrees for parallel developmentWorking on multiple branches simultaneously
proofCreate, edit, and share documents via Proof collaborative editorSharing plans/brainstorms for collaboration
resolve-pr-parallelResolve PR review comments in parallelRunning /resolve_pr_parallel command
setupConfigure which review agents run for your projectRunning /ce:review --setup or initial setup
The brainstorming skill provides:Question patterns:
  • Open-ended exploration questions
  • Multiple choice for common decisions
  • YAGNI prompts (“Do you really need…?”)
  • Constraint discovery questions
  • Success criteria validation
Approach exploration:
  • Generating 2-3 concrete alternatives
  • Pros/cons analysis framework
  • Simplicity bias (prefer simpler solutions)
  • Leading with recommendations
Document structure:
  • What We’re Building
  • Why This Approach
  • Key Decisions
  • Open Questions
  • Next Steps
Loads automatically when running /ce:brainstorm.
The file-todos skill provides a system for tracking todos across files:Format:
# TODO.md

## Feature: User Authentication
- [ ] Implement login flow (app/controllers/sessions_controller.rb:42)
- [ ] Add password reset (app/mailers/user_mailer.rb:15)
- [x] Write tests (spec/features/authentication_spec.rb:10)
Features:
  • File and line number references
  • Hierarchical organization
  • Checkbox tracking
  • Links to specific code locations
Includes template: file-todos/assets/todo-template.md

​
Multi-Agent Orchestration

Skills for coordinating multiple AI agents working in parallel.
SkillDescriptionWhen It Activates
orchestrating-swarmsComprehensive guide to multi-agent swarm orchestrationRunning /slfg, coordinating parallel agents
The orchestrating-swarms skill provides patterns for:Parallel agent execution:
  • Spawning 10, 20, 30+ agents simultaneously
  • Task decomposition strategies
  • Result aggregation patterns
  • Conflict resolution when agents disagree
Use cases:
  • Running all review agents in parallel (security, performance, style, etc.)
  • Parallel code generation for multiple files
  • Simultaneous research across multiple domains
  • Distributed testing and validation
Patterns:
Task security-sentinel: "Review authentication"
Task performance-oracle: "Analyze queries"
Task kieran-rails-reviewer: "Check conventions"
Task dhh-rails-reviewer: "Verify style"
# All 4 run simultaneously
Used by /slfg (swarm LFG) for maximum parallelization.

​
File Transfer

Skills for uploading files to cloud storage.
SkillDescriptionWhen It Activates
rcloneUpload files to S3, Cloudflare R2, Backblaze B2, and cloud storageUploading files, cloud storage operations
The rclone skill supports file uploads to:
  • AWS S3
  • Cloudflare R2
  • Backblaze B2
  • Google Cloud Storage
  • Azure Blob Storage
  • DigitalOcean Spaces
  • And 40+ other cloud storage providers
Requirements:
  • rclone installed (brew install rclone or apt install rclone)
  • Configured remote in ~/.config/rclone/rclone.conf
Usage:
rclone copy local-file.txt remote:bucket/path/
The skill provides configuration examples and common usage patterns.

​
Browser Automation

Skills for automating browser interactions.
SkillDescriptionWhen It Activates
agent-browserCLI-based browser automation using Vercel’s agent-browserBrowser testing, web scraping, E2E tests
The agent-browser skill uses Vercel’s agent-browser CLI for browser automation.Installation:
npm install -g agent-browser
agent-browser install  # Downloads Chromium
Features:
  • Headless browser control
  • Screenshot capture
  • Form filling and interaction
  • Page navigation and waiting
  • JavaScript execution
Used by:
  • /test-browser - Test PR-affected pages
  • /feature-video - Record feature walkthroughs
Example:
agent-browser navigate https://example.com
agent-browser click "#login-button"
agent-browser fill "#email" "[email protected]"
agent-browser screenshot login.png
See agent-browser/SKILL.md for comprehensive CLI reference.

​
Image Generation

Skills for generating and editing images using AI.
SkillDescriptionWhen It Activates
gemini-imagegenGenerate and edit images using Google’s Gemini APIImage generation, image editing tasks
Features:
  • Text-to-image generation - Create images from descriptions
  • Image editing and manipulation - Modify existing images
  • Multi-turn refinement - Iteratively improve images
  • Multiple reference composition - Combine up to 14 reference images
Requirements:
  • GEMINI_API_KEY environment variable set
  • Python packages: google-genai, pillow
Installation:
export GEMINI_API_KEY=your-api-key
pip install google-genai pillow
Example usage:
Generate a hero image for our landing page:
- Modern, minimalist design
- Blue and white color scheme
- Show collaboration between humans and AI
- 1200x630 dimensions for social sharing
The skill provides detailed API usage and prompting patterns.

​
Skill Locations

Skills are stored in the plugin directory: 
plugins/compound-engineering/skills/
├── agent-native-architecture/
│   ├── SKILL.md
│   └── references/
│       ├── mcp-tool-design.md
│       ├── system-prompt-design.md
│       └── ...
├── dhh-rails-style/
│   ├── SKILL.md
│   └── references/
│       ├── architecture.md
│       ├── controllers.md
│       └── ...
├── brainstorming/
│   └── SKILL.md
└── ...
Each skill has:
  • SKILL.md - Main skill file with instructions
  • references/ - Supporting documentation (optional)
  • assets/ - Templates and examples (optional)
  • scripts/ - Executable helpers (optional)
  • workflows/ - Sub-workflows (optional)

​
Creating Custom Skills

Use the /create-agent-skill command to create new skills: 
/create-agent-skill
This loads the create-agent-skills skill which provides:
  • Skill structure templates
  • Best practices for skill writing
  • Validation workflows
  • Reference organization patterns
Skill frontmatter format: 
---
name: my-skill-name
description: What it does and when to use it. Explains code with diagrams. Use when exploring how code works.
---
The description should explain what the skill does and when to use it. See the skill-creator reference for detailed guidance.

​
Skill Compliance

All skills in this plugin follow the official Claude Code skill specification:
Key requirements:
  • YAML frontmatter - name and description required
  • Markdown links - All references must use proper markdown links, not backticks
  • Imperative style - Use verb-first instructions (“Run X”, “Check Y”)
  • Objective language - Avoid second person (“you should”), use objective tone
The /heal-skill command can fix common compliance issues automatically.

​
See Also