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

```

1. Title & Purpose
   ```markdown
   # Skill Name

## Purpose
Clear, concise statement of what this skill does
```

1. When to Use
   ```markdown
   ## When to Use
2. Specific trigger 1
3. Specific trigger 2

4. Context where this helps
   ```

5. 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

1. Workflow
   ```markdown
   ## Workflow

2. Step 1: What to do first

3. Step 2: Next action

4. Step 3: Final deliverable
   ```

5. Best Practices
   ```markdown
   ## Best Practices

6. Do this

7. Avoid that

8. Remember this
   ```

9. Examples
   ```markdown
   ## Examples

### Example 1: Common Use Case
Input: User request
Approach: How to handle
Output: Expected result
```

1. 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

---
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

---
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:

## 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:

---
name: skill-name
description: One-line description
---

Skill Integration

Cross-References

Link to related skills:

## 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:

## 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.