skill-harvester（技能收割机）

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:

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

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

# 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

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

# Create skills-to-harvest.txt
cat > skills-to-harvest.txt << EOF
Category|Name|Description
devops|docker-layer-optimization|Optimize Docker image layers for faster builds and smaller images
backend|api-rate-limiting|Implement rate limiting for API endpoints with Redis
testing|snapshot-testing|Create and manage snapshot tests for UI components
EOF

./bulk-harvest.sh skills-to-harvest.txt

Git History Analysis

#!/bin/bash
# analyze-work.sh - Analyze recent work for harvestable patterns

echo "=== Most Modified Files ==="
git log --since="1 month ago" --pretty=format: --name-only | \
    sort | uniq -c | sort -rg | head -20

echo ""
echo "=== Technologies Used ==="
git log --since="1 month ago" --pretty=format:"%s" | \
    grep -oE "(docker|kubernetes|terraform|ansible|python|node|react|vue|postgres|redis|mongodb)" | \
    sort | uniq -c | sort -rg

echo ""
echo "=== Common Commit Themes ==="
git log --since="1 month ago" --pretty=format:"%s" | \
    grep -oE "^(feat|fix|refactor|docs|test|chore)" | \
    sort | uniq -c | sort -rg

echo ""
echo "=== Recent Problem Areas ==="
git log --since="1 month ago" --all --grep="fix\|bug\|issue" --pretty=format:"%h %s" | head -10

Quality Checklist

Before publishing a harvested skill, ensure:

Completeness:

• Clear, descriptive name (kebab-case)
• Concise description (1-2 sentences)
• "When to Use" section with specific scenarios
• Core concepts explained
• Step-by-step workflow
• At least 2 working examples
• Best practices (DO and DON'T)
• Troubleshooting section
• Quick reference or cheat sheet

Quality:

• Examples are copy-pasteable and work
• Code is well-commented
• Explanations are clear and concise
• Covers common edge cases
• Includes error handling
• Performance considerations mentioned
• Security implications addressed
• Links to official documentation

Usefulness:

• Solves a real problem
• Applicable to multiple scenarios
• More efficient than starting from scratch
• Includes domain expertise
• Provides actionable guidance

Organization:

• Placed in correct category
• Properly tagged
• No duplication with existing skills
• Clear relationship to related skills

Integration Workflow

Step 1: Create in Harvestable Directory

mkdir -p harvestable_skills/[category]/[skill-name]
# Create skill.md with full content

Step 2: Review and Refine

• Test all examples
• Verify instructions
• Add missing sections
• Improve clarity

Step 3: Move to Skills Collection

# Copy to final location
cp -r harvestable_skills/[category]/[skill-name] skills/

# Or organize by category
cp -r harvestable_skills/[category]/[skill-name] skills-by-category/[category]/

Step 4: Commit and Share

git add skills/ harvestable_skills/
git commit -m "🎯 Harvest skills: [description]"
git push

Examples of Harvested Skills

Example 1: From Infrastructure Work → Skill

Original work: Managing Proxmox VE cluster with containers and VMs

Harvested skill: proxmox-manager

• Container lifecycle management
• VM provisioning
• GPU passthrough configuration
• Network troubleshooting
• Backup and restore procedures

Example 2: From Problem Solving → Skill

Original work: Dealing with Claude Code timeouts during bulk operations

Harvested skill: session-timeout-handler

• Chunking strategies
• Checkpoint patterns
• Progress tracking
• Resume mechanisms
• Background process management

Example 3: From Workflow → Skill

Original work: Managing multiple Git repositories with Claude-specific branching

Harvested skill: claude-git-branching

• Branch naming conventions
• Push with retry logic
• Multi-repo coordination
• Conflict resolution
• PR automation

Tips for Effective Harvesting

🎯 Focus on Value

Harvest skills that:

• Save significant time
• Reduce errors
• Encode expertise
• Enable new capabilities
• Solve recurring problems

📝 Document Context

Include:

• Why this approach works
• When to use alternatives
• Trade-offs and considerations
• Real-world scenarios
• Lessons learned

🔄 Iterate and Improve

• Start with basic version
• Add examples from actual use
• Incorporate feedback
• Refine based on experience
• Version as needed

🤝 Share and Collaborate

• Contribute to team repositories
• Accept contributions
• Review and merge improvements
• Build on others' skills
• Create skill compositions

Skill Composition

Combine multiple skills for powerful workflows:

# Example: Full-Stack Deployment Skill

Combines:
- docker-optimization (build efficient images)
- kubernetes-deploy (deploy to cluster)
- database-migration (update schema)
- health-check-monitoring (verify deployment)
- rollback-strategy (revert if needed)

Measurement and Tracking

Track the value of your skills:

# Track skill usage
echo "$(date): Used skill-harvester for project X" >> ~/.claude/skill-usage.log

# Count skill reuse
grep "skill-harvester" ~/.claude/skill-usage.log | wc -l

# Measure time saved
# Before: 4 hours to set up manually
# After: 20 minutes with skill
# Savings: 3.67 hours per use

Advanced Patterns

Pattern 1: Progressive Disclosure

Start with simple template, add complexity as needed:

1. Basic: Essential operations only
2. Intermediate: Common patterns and variations
3. Advanced: Edge cases and optimizations
4. Expert: Deep dives and internals

Pattern 2: Skill Families

Create related skills that work together:

database-skills/
├── postgres-optimization/
├── postgres-backup/
├── postgres-replication/
└── postgres-monitoring/

Pattern 3: Meta-Skills

Skills that help create or manage other skills:

• skill-harvester (this skill)
• skill-tester (validate skills work)
• skill-documenter (generate documentation)
• skill-versioner (manage versions)

Resources

Skill Repositories

• anthropics/claude-code-skills
• Community skill collections
• Team-specific repositories

Tools

• Git for version control
• Markdown for documentation
• YAML for metadata
• Shell scripts for automation

Best Practices

• Follow Claude Code skill conventions
• Use consistent formatting
• Include metadata frontmatter
• Tag appropriately
• Version when needed

Version: 1.0.0 Author: Harvested from your_claude_skills repository Last Updated: 2025-11-18 License: MIT

Quick Start

1. Reflect: Review your recent work (git log, files changed, problems solved)
2. Identify: List 3-7 skills worth harvesting
3. Create: Use the skill template for each
4. Organize: Place in appropriate category
5. Commit: Add to repository
6. Share: Push and make available to team

Remember: The best skills solve real problems and encode genuine expertise. Happy harvesting! 🎯