--- name: when-analyzing-skill-gaps-use-skill-gap-analyzer version: 1.0.0 description: Analyze skill library to identify coverage gaps, redundant overlaps, optimization opportunities, and provide recommendations for skill portfolio improvement tags: - meta-tool - skill-management - gap-analysis - portfolio-optimization complexity: MEDIUM agents_required: - researcher - code-analyzer auto_trigger: false --- # Skill Gap Analyzer **Purpose:** Perform comprehensive analysis of skill library to identify missing capabilities, redundant functionality, optimization opportunities, and provide actionable recommendations for skill portfolio improvement. ## When to Use This Skill - When building a new skill library - Quarterly skill portfolio reviews - Before large refactoring efforts - When considering new skill additions - After major project pivots - When optimizing resource allocation ## Analysis Dimensions ### 1. Coverage Gap Analysis - Domain coverage mapping - Missing capability identification - Use case scenario testing - Workflow completeness assessment - Integration point analysis ### 2. Redundancy Detection - Duplicate functionality identification - Overlapping capability mapping - Consolidation opportunity analysis - Version conflict detection - Naming collision identification ### 3. Optimization Opportunities - Under-utilized skill detection - Over-complex skill identification - Composability improvement suggestions - Dependency optimization - Performance bottleneck analysis ### 4. Usage Pattern Analysis - Frequency metrics - Co-occurrence patterns - Success rate tracking - Token efficiency measurement - Agent utilization patterns ### 5. Recommendation Generation - Prioritized action items - Consolidation strategies - New skill proposals - Deprecation candidates - Restructuring plans ## Execution Process ### Phase 1: Library Inventory ```bash # Initialize analysis session npx claude-flow@alpha hooks pre-task --description "Analyzing skill library gaps" # Scan skill directories find ~/.claude/skills -name "SKILL.md" -o -name "*.skill.md" ``` **Inventory Script:** ```javascript function inventorySkills(skillDirectory) { const inventory = { totalSkills: 0, categories: {}, capabilities: {}, agents: {}, complexity: {}, tags: {} }; // Parse each SKILL.md file const skillFiles = findSkillFiles(skillDirectory); for (const file of skillFiles) { const metadata = parseYAMLFrontmatter(file); inventory.totalSkills++; // Categorize by path const category = extractCategory(file); inventory.categories[category] = (inventory.categories[category] || 0) + 1; // Track capabilities const capabilities = extractCapabilities(metadata.description); capabilities.forEach(cap => { inventory.capabilities[cap] = (inventory.capabilities[cap] || []); inventory.capabilities[cap].push(metadata.name); }); // Track required agents if (metadata.agents_required) { metadata.agents_required.forEach(agent => { inventory.agents[agent] = (inventory.agents[agent] || 0) + 1; }); } // Track complexity inventory.complexity[metadata.complexity || 'UNKNOWN'] = (inventory.complexity[metadata.complexity || 'UNKNOWN'] || 0) + 1; // Track tags if (metadata.tags) { metadata.tags.forEach(tag => { inventory.tags[tag] = (inventory.tags[tag] || 0) + 1; }); } } return inventory; } function extractCapabilities(description) { // Extract action verbs and key nouns const capabilities = []; const verbs = description.match(/\b(analyz|creat|generat|optimiz|manag|coordinat|orchestrat|deploy|monitor|test|review|document|integrat|automat|validat|secur|perform|debug|refactor|migrat|transform)\w+/gi) || []; capabilities.push(...verbs.map(v => v.toLowerCase())); return [...new Set(capabilities)]; // Deduplicate } ``` **Store Inventory:** ```bash npx claude-flow@alpha memory store --key "gap-analysis/inventory" --value "{ \"totalSkills\": , \"categories\": {...}, \"capabilities\": {...}, \"timestamp\": \"\" }" ``` ### Phase 2: Coverage Gap Detection **Domain Coverage Matrix:** ```javascript function analyzeCoverageGaps(inventory, requiredDomains) { const gaps = []; // Define comprehensive domain requirements const domains = { "Development": [ "code-generation", "testing", "debugging", "refactoring", "documentation", "code-review", "architecture" ], "DevOps": [ "deployment", "monitoring", "ci-cd", "infrastructure", "security", "scaling", "backup-recovery" ], "Project Management": [ "planning", "estimation", "tracking", "reporting", "risk-management", "stakeholder-communication" ], "Data": [ "data-analysis", "data-transformation", "data-validation", "data-migration", "data-visualization" ], "AI/ML": [ "model-training", "inference", "optimization", "evaluation", "deployment", "monitoring" ], "Integration": [ "api-integration", "webhook-handling", "event-processing", "message-queue", "service-mesh" ] }; // Check coverage for each domain for (const [domain, capabilities] of Object.entries(domains)) { const coverage = capabilities.map(cap => { const covered = inventory.capabilities[cap]?.length > 0; const skills = inventory.capabilities[cap] || []; return { capability: cap, covered, skills }; }); const missingCaps = coverage.filter(c => !c.covered); if (missingCaps.length > 0) { gaps.push({ domain: domain, coverage: ((capabilities.length - missingCaps.length) / capabilities.length * 100).toFixed(1) + "%", missingCapabilities: missingCaps.map(c => c.capability), priority: calculatePriority(domain, missingCaps.length, capabilities.length) }); } } return gaps; } function calculatePriority(domain, missingCount, totalCount) { const coverageRatio = 1 - (missingCount / totalCount); const domainImportance = { "Development": 1.0, "DevOps": 0.9, "Project Management": 0.7, "Data": 0.8, "AI/ML": 0.8, "Integration": 0.9 }; const score = coverageRatio * (domainImportance[domain] || 0.5); if (score < 0.3) return "critical"; if (score < 0.6) return "high"; if (score < 0.8) return "medium"; return "low"; } ``` **Use Case Scenario Testing:** ```javascript function testScenarioCoverage(inventory) { const scenarios = [ { name: "Full-stack web app development", requiredCapabilities: [ "code-generation", "testing", "database-design", "api-integration", "deployment", "monitoring" ] }, { name: "ML model training and deployment", requiredCapabilities: [ "data-analysis", "model-training", "evaluation", "optimization", "deployment", "monitoring" ] }, { name: "GitHub workflow automation", requiredCapabilities: [ "code-review", "testing", "ci-cd", "release-management", "issue-tracking", "documentation" ] }, { name: "Prompt engineering and optimization", requiredCapabilities: [ "prompt-analysis", "optimization", "testing", "documentation", "version-control" ] } ]; const scenarioResults = scenarios.map(scenario => { const coverage = scenario.requiredCapabilities.map(cap => ({ capability: cap, covered: inventory.capabilities[cap]?.length > 0, skills: inventory.capabilities[cap] || [] })); const coveragePercent = (coverage.filter(c => c.covered).length / coverage.length * 100).toFixed(1); return { scenario: scenario.name, coverage: coveragePercent + "%", missing: coverage.filter(c => !c.covered).map(c => c.capability), canExecute: coverage.every(c => c.covered) }; }); return scenarioResults; } ``` ### Phase 3: Redundancy Detection **Overlap Analysis:** ```javascript function detectRedundancy(inventory) { const redundancies = []; // Find capabilities handled by multiple skills for (const [capability, skills] of Object.entries(inventory.capabilities)) { if (skills.length > 2) { // Analyze actual overlap const skillDetails = skills.map(name => loadSkillDetails(name)); const overlap = analyzeOverlap(skillDetails); if (overlap.percentage > 70) { redundancies.push({ capability: capability, skillCount: skills.length, skills: skills, overlapPercentage: overlap.percentage, recommendation: generateConsolidationRecommendation(skillDetails) }); } } } // Find naming collisions const namePatterns = {}; for (const [category, skillList] of Object.entries(inventory.categories)) { // Extract common patterns const patterns = skillList.map(extractNamePattern); // Identify potential confusion } return redundancies; } function analyzeOverlap(skills) { // Compare descriptions, capabilities, processes const descriptions = skills.map(s => s.description); const commonWords = findCommonWords(descriptions); // Calculate Jaccard similarity const allWords = new Set(descriptions.flatMap(d => d.split(/\s+/))); const overlap = commonWords.size / allWords.size * 100; return { percentage: overlap, commonWords: Array.from(commonWords) }; } ``` ### Phase 4: Optimization Opportunities **Researcher Agent Task:** ```bash # Spawn researcher agent for optimization analysis # Agent instructions: # 1. Analyze usage patterns from memory # 2. Identify under-utilized skills (low frequency) # 3. Identify over-complex skills (high token cost, low success rate) # 4. Suggest composability improvements # 5. Recommend dependency optimizations # 6. Store findings in memory npx claude-flow@alpha memory store --key "gap-analysis/optimization" --value "{ \"underutilized\": [...], \"overcomplicated\": [...], \"composability\": [...], \"dependencies\": [...] }" ``` **Optimization Detection:** ```javascript function identifyOptimizations(inventory, usageMetrics) { const optimizations = []; // Under-utilized skills const underutilized = usageMetrics.filter(m => m.frequency < 0.05 && // Less than 5% usage m.lastUsed > 90 // Days since last use ).map(m => ({ skill: m.name, frequency: m.frequency, lastUsed: m.lastUsed + " days ago", recommendation: "Review for deprecation or promotion" })); optimizations.push({ type: "under-utilized", count: underutilized.length, skills: underutilized }); // Over-complex skills const overcomplex = usageMetrics.filter(m => m.avgTokens > 5000 && // High token usage m.successRate < 0.7 // Low success rate ).map(m => ({ skill: m.name, avgTokens: m.avgTokens, successRate: (m.successRate * 100).toFixed(1) + "%", recommendation: "Break into smaller skills or simplify" })); optimizations.push({ type: "over-complex", count: overcomplex.length, skills: overcomplex }); // Composability improvements const composable = identifyComposablePatterns(inventory); optimizations.push({ type: "composability", count: composable.length, opportunities: composable }); return optimizations; } ``` ### Phase 5: Recommendation Generation **Report Format:** ```markdown ## Skill Gap Analysis Report **Date:** **Total Skills Analyzed:** **Analysis Duration:**