opencode-skill-auditor

What I do

• Analyze the current set of OpenCode skills for redundancy, overlap, and duplication
• Identify granular functionality that can be extracted into reusable skill components
• Recommend modularization strategies to improve skill ecosystem efficiency
• Ensure proposed new skills follow DRY principles and OpenCode best practices
• Provide comprehensive gap analysis and skill optimization recommendations
• Generate detailed reports on skill interdependencies and coupling issues
• Suggest consolidation opportunities for closely related skillsets

When to use me

Use this when:

• You need to analyze the existing skill ecosystem for optimization opportunities
• You want to identify redundant functionality across multiple skills
• You're planning to refactor or consolidate the skill library
• You need to ensure new skills won't duplicate existing capabilities
• You want to improve maintainability and reduce code duplication in skills
• You're developing a strategy for skill ecosystem growth and organization

Ask me to analyze specific skill directories, focus on particular capability areas, or provide comprehensive ecosystem audits.

Prerequisites

• Access to the skills directory containing all OpenCode skill definitions
• Basic understanding of OpenCode skill structure and YAML frontmatter format
• Familiarity with modular design principles and DRY methodology
• Permission to read and analyze skill documentation files
• (Optional) Git history access for tracking skill evolution and dependencies

Steps

1. Skill Discovery

   bashCopy

   # Locate all skill definitions in the repository
   find . -name "SKILL.md" -type f | sort
   
   # Extract skill metadata for analysis
   grep -h "^name:" skills/*/SKILL.md | sort
   

2. Capability Analysis

   • Read each skill's "What I do" section to identify core functionalities
   • Extract and categorize capability patterns across all skills
   • Map skill descriptions to functional domains and use cases

3. Redundancy Detection

   • Compare skill descriptions for overlapping functionality
   • Identify similar capability patterns and use case scenarios
   • Flag skills with near-identical purposes or target audiences

4. Granularity Assessment

   • Evaluate whether skills can be broken down into smaller, reusable components
   • Identify compound skills that contain multiple distinct capabilities
   • Assess potential for extracting shared functionality into base skills

5. Dependency Mapping

   • Analyze skill interdependencies and coupling relationships
   • Identify skills that reference or build upon other skills
   • Map the skill hierarchy and dependency graph

6. Recommendation Generation

   • Propose specific modularization strategies with concrete examples
   • Suggest skill consolidation opportunities with migration paths
   • Recommend new granular skills to fill identified gaps
   • Provide priority rankings based on impact and feasibility

7. Best Practices Validation

   • Ensure proposed changes follow OpenCode naming conventions
   • Validate that new skill structures maintain proper YAML frontmatter
   • Verify that modularization preserves existing functionality

Best Practices

• Systematic Analysis: Process skills in logical groups by capability domain or workflow type
• Documentation-First: Always preserve existing functionality and user-facing behavior
• Incremental Changes: Propose modularization in stages to minimize disruption
• Backward Compatibility: Ensure existing integrations continue to work during transitions
• Clear Naming: Use descriptive, distinguishable names for new granular skills
• Cross-Reference: Maintain clear documentation of relationships between original and modularized skills
• Community Input: Consider existing usage patterns and community feedback when proposing changes

Common Issues

Issue: Skills appear similar but serve different contexts

• Solution: Focus on specific use cases and target audiences in your analysis
• Consider context-specific optimizations that justify separate skills

Issue: Over-granularization leading to skill fragmentation

• Solution: Balance between reusability and usability
• Group related capabilities logically while maintaining meaningful skill boundaries

Issue: Missing documentation for skill interdependencies

• Solution: Create dependency mapping as part of your analysis
• Document implicit relationships and usage patterns

Issue: Legacy skills with outdated structures

• Solution: Prioritize updates to skills that don't follow current best practices
• Provide migration paths for modernizing skill structures

Issue: Difficulty measuring impact of proposed changes

• Solution: Use usage metrics and community feedback when available
• Implement A/B testing or gradual rollouts for significant changes

Analysis Commands

# Quick skill overview with metadata
for skill in skills/*/SKILL.md; do
  echo "=== $(basename $(dirname "$skill")) ==="
  grep -E "^name:|^description:|^metadata:" "$skill"
  echo
done

# Find skills with similar descriptions
grep -h "^description:" skills/*/SKILL.md | sort | uniq -c | sort -nr

# Analyze skill distribution by workflow type
grep -A1 "workflow:" skills/*/SKILL.md | grep "workflow:" | sort | uniq -c

# Check for naming convention compliance
ls skills/ | grep -E "^[a-z0-9]+(-[a-z0-9]+)*$"