skill-harvester

What this skill does

# Skill Harvester

Transform your past work into reusable Claude Code skills automatically.

## Overview

The Skill Harvester is a meta-skill that helps you systematically extract reusable patterns, workflows, and expertise from your Claude Code sessions and convert them into well-structured skills that can be shared and reused.

## When to Use

Use this skill when:
- Completing a significant project or work session
- Identifying repetitive patterns across multiple sessions
- Building organizational knowledge repositories
- Creating team-wide skill libraries
- Documenting complex workflows for future reuse
- Converting infrastructure/tooling expertise into skills
- After solving complex problems that could help future work

## Skill Harvesting Process

### 1. Reflection & Analysis

**Examine recent work:**
```bash
# Review recent git commits
git log --oneline -20

# Analyze file changes
git diff HEAD~10..HEAD --stat

# Check which files were most modified
git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -20
```

**Identify domains:**
- What technologies were used? (frameworks, languages, tools)
- What problems were solved? (deployment, testing, optimization)
- What patterns emerged? (error handling, API integration, workflow)
- What expertise was developed? (domain knowledge, best practices)

### 2. Skill Identification

**Questions to ask:**
1. **Reusability**: Could this help in future projects?
2. **Generalizability**: Does it apply beyond this specific context?
3. **Complexity**: Is it non-trivial enough to warrant a skill?
4. **Value**: Would others benefit from this pattern?
5. **Completeness**: Can it be documented as a standalone skill?

**Skill categories to consider:**
- **Infrastructure**: Docker, Kubernetes, cloud platforms, CI/CD
- **Backend**: API design, database optimization, authentication
- **Frontend**: Component patterns, state management, build optimization
- **DevOps**: Deployment strategies, monitoring, automation
- **Data Engineering**: ETL pipelines, data validation, transformation
- **Security**: Auth patterns, encryption, vulnerability scanning
- **Testing**: Test strategies, mocking, coverage analysis
- **Documentation**: API docs, architecture diagrams, runbooks

### 3. Skill Template Creation

**Essential components of a good skill:**

```markdown
---
name: skill-name (kebab-case)
description: Clear, concise 1-2 sentence description of what the skill does
license: MIT
tags: [relevant, searchable, tags]
---

# Skill Title

Brief overview paragraph explaining the skill's purpose and value.

## When to Use

- Specific scenario 1
- Specific scenario 2
- Specific scenario 3

## Core Concepts

Explain the fundamental ideas and principles.

## Workflow

Step-by-step process for using the skill.

### Step 1: [Action]
Detailed explanation with code examples.

### Step 2: [Action]
More details and examples.

## Common Patterns

### Pattern 1: [Name]
Description and example.

### Pattern 2: [Name]
Description and example.

## Best Practices

### ✅ DO
- Recommended approach 1
- Recommended approach 2

### ❌ DON'T
- Anti-pattern 1
- Anti-pattern 2

## Examples

### Example 1: [Scenario]
Full working example with explanation.

### Example 2: [Scenario]
Another complete example.

## Troubleshooting

### Issue 1: [Problem]
**Symptoms**: What you see
**Cause**: Why it happens
**Solution**: How to fix

## Reference

Quick reference table or cheat sheet.

## Additional Resources

- Links to relevant documentation
- Related skills
- External references
```

### 4. Content Extraction

**Extract from various sources:**

```bash
# From code files
# Look for:
# - Complex functions that solve specific problems
# - Utility scripts with general applicability
# - Configuration patterns that work well
# - Error handling strategies
# - Integration patterns

# From documentation
# Harvest:
# - README instructions
# - Setup guides
# - Troubleshooting notes
# - Architecture decisions
# - Lessons learned

# From git commits
git log --all --grep="fix\|feat\|refactor" --pretty=format:"%h %s" -20

# From issue trackers
# Extract:
# - Common problems and solutions
# - Debugging strategies
# - Workarounds and fixes
```

### 5. Skill Organization

**Directory structure:**
```
harvestable_skills/
├── automation/
│   ├── skill-name/
│   │   └── skill.md
├── backend/
├── devops/
├── frontend/
├── infrastructure/
├── testing/
└── documentation/
```

**Categorization guidelines:**
- **automation**: Workflow automation, scripting, batch operations
- **backend**: Server-side development, APIs, databases
- **cloud**: Cloud platforms, serverless, infrastructure
- **data-engineering**: Data processing, ETL, analytics
- **devops**: CI/CD, deployment, monitoring
- **documentation**: Documentation generation, diagrams
- **frontend**: UI development, client-side frameworks
- **infrastructure**: Container orchestration, VMs, networking
- **security**: Authentication, authorization, encryption
- **testing**: Test frameworks, strategies, automation
- **web-development**: Full-stack web development patterns

## Harvesting Strategies

### Strategy 1: Domain Expertise Extraction

When you've worked extensively with a specific tool or technology:

1. **Document the mental model**: How does it work? What are the key concepts?
2. **Capture common operations**: What do you do most often?
3. **Record gotchas**: What are the common pitfalls?
4. **Create quick reference**: What do you always look up?

**Example domains:**
- Database query optimization
- Docker multi-stage builds
- JWT authentication patterns
- GraphQL schema design
- Terraform module creation

### Strategy 2: Workflow Pattern Extraction

When you've developed an effective workflow:

1. **Map the steps**: What's the sequence of actions?
2. **Identify decision points**: Where are choices made?
3. **Document prerequisites**: What's needed to start?
4. **Capture success criteria**: How do you know it worked?

**Example workflows:**
- Blue-green deployments
- Feature branch review process
- Database migration strategies
- API versioning approaches

### Strategy 3: Problem-Solution Pattern Mining

When you've solved complex problems:

1. **Describe the problem**: What was broken/missing?
2. **Explain the diagnosis**: How did you identify it?
3. **Detail the solution**: What fixed it?
4. **Generalize the pattern**: How to prevent/solve similar issues?

**Example patterns:**
- Memory leak debugging
- Race condition resolution
- Performance bottleneck analysis
- Security vulnerability patching

### Strategy 4: Tool Mastery Documentation

When you've become proficient with a tool:

1. **Core operations**: What are the essential commands?
2. **Advanced features**: What are the power-user tricks?
3. **Integration patterns**: How does it work with other tools?
4. **Troubleshooting**: Common errors and fixes?

**Example tools:**
- kubectl for Kubernetes
- AWS CLI for cloud operations
- jq for JSON processing
- git for version control

## Automation Helpers

### Bulk Skill Generation

```bash
#!/bin/bash
# bulk-harvest.sh - Generate multiple skills from a list

SKILLS_FILE="$1"
OUTPUT_DIR="harvestable_skills"

while IFS='|' read -r category name description; do
    # Skip header and empty lines
    [[ "$category" == "Category" ]] && continue
    [[ -z "$category" ]] && continue

    SKILL_DIR="$OUTPUT_DIR/$category/$name"
    mkdir -p "$SKILL_DIR"

    cat > "$SKILL_DIR/skill.md" << EOF
---
name: $name
description: $description
license: MIT
---

# ${name//\-/ }

$description

## When to Use

TODO: Add specific scenarios

## Implementation

TODO: Add implementation details

## Examples

TODO: Add working examples

## Best Practices

TODO: Add recommendations
EOF

    echo "✓ Created: $category/$name"
done < "$SKILLS_FILE"
```

**Usage:**
```bash
# Create skills-to-harvest.txt
cat > skills-to-harvest.txt << EOF
Category|Name|Description
devops|docker-layer-optimization|Optimize Docker image layers for faster bu