skill-creator-skill skill

---
name: skill-creator
description: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
---

# Skill Creator

## Purpose

A meta-skill that guides the creation of high-quality, effective skills. Provides templates, best practices, and structural guidelines for building skills that enhance Claude's capabilities with specialized knowledge, workflows, or tool integrations.

## When to Use

- User wants to create a new skill
- User wants to update or improve an existing skill  
- User asks how to structure skill documentation
- Need to design a skill for a specific domain or workflow
- Want to ensure skill follows best practices

## Core Skill Structure

### Required Components

Every skill must have these elements:

1. **Frontmatter**
   ```yaml
   ---
   name: skill-name
   description: One-line description when to use this skill
   ---
   ```

2. **Title & Purpose**
   ```markdown
   # Skill Name
   
   ## Purpose
   Clear, concise statement of what this skill does
   ```

3. **When to Use**
   ```markdown
   ## When to Use
   - Specific trigger 1
   - Specific trigger 2
   - Context where this helps
   ```

4. **Core Capabilities**
   ```markdown
   ## Core Capabilities
   
   ### Domain Expertise
   - Key knowledge area 1
   - Key knowledge area 2
   
   ### Tools & Methods
   - Specific techniques
   - Frameworks used
   ```

### Optional but Recommended Components

5. **Workflow**
   ```markdown
   ## Workflow
   
   1. Step 1: What to do first
   2. Step 2: Next action
   3. Step 3: Final deliverable
   ```

6. **Best Practices**
   ```markdown
   ## Best Practices
   
   - Do this
   - Avoid that
   - Remember this
   ```

7. **Examples**
   ```markdown
   ## Examples
   
   ### Example 1: Common Use Case
   **Input**: User request
   **Approach**: How to handle
   **Output**: Expected result
   ```

8. **Anti-Patterns**
   ```markdown
   ## Anti-Patterns
   
   ❌ **Don't**: Bad practice
   ✅ **Do**: Good alternative
   ```

## Skill Creation Workflow

### Step 1: Define Scope

Ask yourself:
- What problem does this skill solve?
- Who will use it?
- What triggers its use?
- What's the expected outcome?

### Step 2: Identify Core Knowledge

Document:
- Domain-specific terminology
- Key concepts and principles
- Common patterns in this domain
- Tools and technologies involved

### Step 3: Structure the Workflow

Map out:
- Entry conditions
- Step-by-step process
- Decision points
- Exit criteria and deliverables

### Step 4: Add Practical Elements

Include:
- Real-world examples
- Common pitfalls to avoid
- Best practices from the field
- Quality criteria

### Step 5: Write Clear Triggers

Make "When to Use" specific:
- ✅ "User needs SQL query optimization for PostgreSQL databases"
- ❌ "User needs database help"

- ✅ "Debugging production outages in distributed systems"
- ❌ "Fixing bugs"

## Skill Quality Criteria

### Clarity
- [ ] Name is self-explanatory
- [ ] Description clearly states when to use
- [ ] Purpose is stated in 1-2 sentences
- [ ] No jargon without explanation

### Completeness
- [ ] All required sections present
- [ ] Workflow is actionable
- [ ] Examples cover common cases
- [ ] Edge cases addressed

### Specificity
- [ ] Triggers are concrete
- [ ] Steps are detailed enough to follow
- [ ] Tools/methods are named explicitly
- [ ] Success criteria defined

### Usability
- [ ] Easy to scan and navigate
- [ ] Consistent formatting
- [ ] Logical section ordering
- [ ] Cross-references where helpful

## Skill Templates

### Technical Domain Skill Template

```markdown
---
name: domain-expert
description: Use when user needs [specific technical task] in [technology/domain]
---

# Domain Expert

## Purpose

Expert in [domain] specializing in [specific areas]. Helps with [key problems solved].

## When to Use

- User needs [specific task 1]
- Working with [technology] and needs [help type]
- Troubleshooting [specific problem type]
- Designing [architectural element]

## Core Capabilities

### [Domain] Expertise
- [Technology 1] - [version/specifics]
- [Technology 2] - [what aspects]
- [Pattern/practice] - [when/how]

### Key Techniques
- **[Technique 1]**: [What it solves]
- **[Technique 2]**: [When to use]
- **[Technique 3]**: [How it helps]

## Workflow

1. **Understand Requirements**
   - Clarify [specific aspects]
   - Identify [constraints]

2. **Apply [Domain] Patterns**
   - Use [pattern 1] for [scenario]
   - Consider [trade-off]

3. **Implement Solution**
   - Follow [best practice]
   - Ensure [quality criteria]

4. **Validate**
   - Test [aspects]
   - Verify [requirements met]

## Best Practices

- **[Practice 1]**: [Reasoning]
- **[Practice 2]**: [Benefit]
- **[Practice 3]**: [Why important]

## Common Patterns

### [Pattern 1]
**When**: [Scenario]
**How**: [Implementation approach]
**Why**: [Benefits]

### [Pattern 2]
**When**: [Scenario]
**How**: [Implementation approach]
**Why**: [Benefits]

## Anti-Patterns

❌ **Don't**: [Bad practice]
   - Why it fails: [Reason]
   - Better approach: [Alternative]

❌ **Avoid**: [Common mistake]
   - Problem: [What goes wrong]
   - Instead: [Correct way]

## Examples

### Example 1: [Common Scenario]
**Context**: [Situation]
**Approach**: [Solution steps]
**Result**: [Outcome]

## Tools & Technologies

- **[Tool 1]**: [Version] - [Use for what]
- **[Tool 2]**: [Version] - [Use for what]
- **[Framework]**: [Version] - [Key features used]
```

### Process/Workflow Skill Template

```markdown
---
name: process-specialist
description: Use when user needs [specific process/workflow] for [outcome]
---

# Process Specialist

## Purpose

Guides [specific process] to achieve [specific outcome]. Ensures [quality aspects] through [methodology].

## When to Use

- Need to [execute process]
- Want to ensure [quality outcome]
- Working on [scenario requiring this process]

## Core Process

### Phase 1: [Name]
**Goal**: [What to achieve]

Steps:
1. [Action 1]: [Details]
2. [Action 2]: [Details]
3. [Action 3]: [Details]

**Outputs**: [What you have after this phase]

### Phase 2: [Name]
**Goal**: [What to achieve]

Steps:
1. [Action 1]: [Details]
2. [Action 2]: [Details]

**Outputs**: [What you have after this phase]

### Phase 3: [Name]
**Goal**: [What to achieve]

Steps:
1. [Action 1]: [Details]
2. [Action 2]: [Details]

**Deliverable**: [Final output]

## Decision Points

### When to [Decision]
- If [condition], then [choice A]
- If [condition], then [choice B]

## Quality Gates

After each phase, verify:
- [ ] [Criterion 1]
- [ ] [Criterion 2]
- [ ] [Criterion 3]

## Best Practices

- **[Practice]**: [Why it matters]
- **[Practice]**: [Impact on quality]

## Common Pitfalls

- **Pitfall**: [What people do wrong]
  - **Impact**: [What happens]
  - **Solution**: [How to avoid]
```

## Writing Tips

### Be Specific
❌ "Use when working with databases"
✅ "Use when optimizing SQL queries for PostgreSQL 14+ production databases"

### Be Actionable
❌ "Think about security"
✅ "Run OWASP ZAP scan and review all HIGH severity findings"

### Be Structured
Use consistent heading levels:
- `##` for major sections
- `###` for subsections
- `####` for detailed breakdowns

### Use Visual Indicators
- ✅ for good practices
- ❌ for anti-patterns
- 🔍 for investigation steps
- ⚠️ for warnings
- 💡 for tips

### Include Context
Don't just list what to do—explain why:
```markdown
## Instead of:
- Use connection pooling

## Write:
- **Use connection pooling** (pg-pool for PostgreSQL)
  - Reduces connection overhead by 80%
  - Critical for applications with >100 concurrent users
  - Configure pool size = (core count × 2) + effective_spindle_count
```

## Skill Maintenance

### When to Update
- New version of core technology released
- Better practices emerge in the field
- User feedback reveals gaps
- Related skills are created (cross-reference)

### Version Control
Consider adding to frontmatter:
```yaml
---
name: skill-name
description: One-line description
---
```

## Skill Integration

### Cross-References
Link to related skills:
```markdown
## Related Skills
- Use [[debugger-skill]] when issues arise
- Combine with [[performance-engineer-skill]] for optimization
- Precede with [[architect-reviewer-skill]] for design validation
```

### Skill Composition
Complex workflows can chain skills:
```markdown
## Workflow
1. Use [[requirement-analyst]] to gather needs
2. Apply this skill for implementation
3. Use [[code-reviewer]] for quality assurance
4. Use [[deployment-engineer]] to ship
```

## Examples

### Example 1: Creating a Python Pro Skill

**Context**: Need a skill for advanced Python development

**Process**:
1. Define scope: Python 3.11+ with focus on FastAPI and type safety
2. Identify triggers: "modern Python", "type hints", "FastAPI"
3. Structure core capabilities:
   - Python 3.11+ features (match statements, typing improvements)
   - FastAPI framework patterns
   - Type annotation best practices
4. Add workflow: Design API → Type models → Implement routes → Test
5. Include examples: FastAPI route with full type annotations

**Result**: A focused, actionable skill for modern Python development

### Example 2: Creating a Git Workflow Skill

**Context**: Need to codify team's git branching strategy

**Process**:
1. Define scope: Git workflow for feature development
2. Identify triggers: "create branch", "make PR", "git workflow"
3. Structure as phases:
   - Branch creation
   - Development cycle
   - PR process
   - Merge strategy
4. Add decision points: When to rebase vs merge
5. Include examples: Standard feature development flow

**Result**: Clear procedural guide for consistent git usage

## Validation Checklist

Before finalizing a skill, check:

### Structure
- [ ] Frontmatter complete (name, description)
- [ ] Title and purpose clear
- [ ] "When to Use" section has specific triggers
- [ ] Core capabilities well-defined

### Content
- [ ] Information is accurate and current
- [ ] Examples are realistic and helpful
- [ ] Best practices are justified
- [ ] Anti-patterns show alternatives

### Usability
- [ ] Can scan and find info quickly
- [ ] Sections flow logically
- [ ] Formatting is consistent
- [ ] Cross-references are correct

### Quality
- [ ] No spelling/grammar errors
- [ ] Technical terms defined
- [ ] Code examples (if any) are correct
- [ ] Meets all quality criteria above

## Meta: About This Skill

This skill itself demonstrates the principles it teaches:
- Clear frontmatter and structure
- Specific "When to Use" triggers
- Actionable workflows
- Concrete examples
- Quality criteria

When creating skills, use this as both a guide and a template.