Skill Reference

You're writing a skill right now, but you're not sure if you're structuring the SKILL.md file correctly. Should the examples go before the theory? How do you organize workflows vs. references? This skill is the answer—it's the master template for building skills themselves.

Capabilities

• Skill architecture and best practices
• Router pattern for complex multi-step skills
• Progressive disclosure design principles
• SKILL.md structure guidance
• Asset management (workflows, references, templates, scripts)
• XML structure patterns

Workflows Included

• create-new-skill - Start from scratch
• add-reference - Add reference documentation
• add-template - Add code templates
• add-workflow - Add step-by-step procedures
• add-script - Add executable scripts
• audit-skill - Validate skill structure
• verify-skill - Test skill functionality

skill: create-agent-skills

The simpler, step-by-step version of create-agent-skills. When you just want a checklist to follow from blank file to packaged skill, use this. It's less about theory, more about "do step 1, then step 2."

6-Step Process

1. Understand skill usage patterns with examples
2. Plan reusable skill contents
3. Initialize skill using template
4. Edit skill with clear instructions
5. Package skill into distributable zip
6. Iterate based on testing feedback

skill: skill-creator

You want Rails controllers that are five lines, not fifty. Models that handle authorization, broadcasting, and business logic without service objects everywhere. This skill teaches Claude to write code the way DHH writes it at 37signals—REST-pure, Hotwire-first, no architectural astronautics.

Key Patterns

• REST Purity - 7 REST actions only
• Fat Models - Business logic, authorization, broadcasting in models
• Thin Controllers - 1-5 line actions
• Current Attributes - Request context
• Hotwire/Turbo - Model-level broadcasting

Ruby Syntax Preferences

• Symbol arrays %i[...]
• Modern hash syntax
• Ternaries for simple conditionals
• Bang methods for mutations

skill: dhh-ruby-style

Andrew Kane has written 100+ Ruby gems with 374 million downloads. Every gem follows the same patterns: minimal dependencies, class macro DSLs, Rails integration without Rails coupling. When you're building a gem and want it to feel production-ready from day one, this is how you do it.

Philosophy

• Simplicity over cleverness
• Zero or minimal dependencies
• Explicit code over metaprogramming
• Rails integration without Rails coupling

Key Patterns

• Class macro DSL for configuration
• ActiveSupport.on_load for Rails integration
• class << self with attr_accessor
• Railtie pattern for hooks
• Minitest (no RSpec)

Reference Files

• references/module-organization.md
• references/rails-integration.md
• references/database-adapters.md
• references/testing-patterns.md

skill: andrew-kane-gem-writer

You're adding AI features to your Rails app, but you don't want brittle prompt strings scattered everywhere. DSPy.rb gives you type-safe signatures, composable predictors, and tool-using agents. This skill shows you how to use it—from basic inference to ReAct agents that iterate until they get the answer right.

Predictor Types

• Predict - Basic inference
• ChainOfThought - Reasoning with explanations
• ReAct - Tool-using agents with iteration
• CodeAct - Dynamic code generation

Supported Providers

• OpenAI (GPT-4, GPT-4o-mini)
• Anthropic Claude
• Google Gemini
• Ollama (free, local)
• OpenRouter

Requirements

skill: dspy-ruby

You've seen what AI usually generates: Inter font, purple gradients, rounded corners on everything. This skill teaches Claude to design interfaces that don't look like every other AI-generated site. It's about purposeful typography, unexpected color palettes, and interfaces with personality.

Design Thinking

• Purpose - What is the interface for?
• Tone - What feeling should it evoke?
• Constraints - Technical and brand limitations
• Differentiation - How to stand out

Focus Areas

• Typography with distinctive font choices
• Color & theme coherence with CSS variables
• Motion and animation patterns
• Spatial composition with asymmetry
• Backgrounds (gradients, textures, patterns)

skill: frontend-design

You just fixed a weird build error after an hour of debugging. Tomorrow you'll forget how you fixed it. This skill automatically detects when you solve something (phrases like "that worked" or "it's fixed") and documents it with YAML frontmatter so you can find it again. Each documented solution compounds your team's knowledge.

Auto-Triggers

Phrases: "that worked", "it's fixed", "working now", "problem solved"

7-Step Process

1. Detect confirmation phrase
2. Gather context (module, symptom, investigation, root cause)
3. Check existing docs for similar issues
4. Generate filename
5. Validate YAML frontmatter
6. Create documentation in category directory
7. Cross-reference related issues

Categories

• build-errors/
• test-failures/
• runtime-errors/
• performance-issues/
• database-issues/
• security-issues/

skill: compound-docs

You wrote a draft, but you're not sure if it matches Every's style guide. Should "internet" be capitalized? Is this comma splice allowed? This skill does a four-phase line-by-line review: context, detailed edits, mechanical checks, and actionable recommendations. It's like having a copy editor who never gets tired.

Four-Phase Review

1. Initial Assessment - Context, type, audience, tone
2. Detailed Line Edit - Sentence structure, punctuation, capitalization
3. Mechanical Review - Spacing, formatting, consistency
4. Recommendations - Actionable improvement suggestions

Style Checks

• Grammar and punctuation
• Style guide compliance
• Capitalization rules
• Word choice optimization
• Formatting consistency

skill: every-style-editor

Your todo list is a bunch of markdown files in a todos/ directory. Each filename encodes status, priority, and description. No database, no UI, just files with YAML frontmatter. When you need to track work without setting up Jira, this is the system.

File Format

# Naming convention
{issue_id}-{status}-{priority}-{description}.md

# Examples
001-pending-p1-security-vulnerability.md
002-ready-p2-performance-optimization.md
003-complete-p3-code-cleanup.md

Status Values

• pending - Needs triage
• ready - Approved for work
• complete - Done

Priority Values

• p1 - Critical
• p2 - Important
• p3 - Nice-to-have

YAML Frontmatter

---
status: pending
priority: p1
issue_id: "001"
tags: [security, authentication]
dependencies: []
---

skill: file-todos

You're working on a feature branch, but you need to review a PR without losing your current work. Git worktrees let you have multiple branches checked out simultaneously in separate directories. This skill manages them—create, switch, cleanup—so you can context-switch without stashing or committing half-finished code.

Commands

# Create new worktree
bash scripts/worktree-manager.sh create feature-login

# List worktrees
bash scripts/worktree-manager.sh list

# Switch to worktree
bash scripts/worktree-manager.sh switch feature-login

# Clean up completed worktrees
bash scripts/worktree-manager.sh cleanup

Integration

• Works with /review for isolated PR analysis
• Works with /work for parallel feature development

Requirements

• Git 2.8+ (for worktree support)
• Worktrees stored in .worktrees/ directory

skill: git-worktree