Skill Ecosystem Cataloging

Skill Ecosystem Cataloging

Cataloging and organizing skill ecosystems — from taxonomy development and category naming through skill relationships, navigation paths, and portfolio management.

When to Use

• Organizing a large skill inventory
• Designing skill categories and subcategories
• Building skill navigation and discovery
• Analyzing skill portfolio balance
• Planning skill taxonomy evolution

Ecosystem Mapping

from typing import Dict, List, Set
from collections import defaultdict

class SkillEcosystem:
    """Map and analyze a skill ecosystem."""
    
    ECOSYSTEM_LAYERS = {
        'foundation': 'Core concepts (programming basics, CS fundamentals)',
        'language': 'Programming languages and runtimes',
        'framework': 'Application frameworks and libraries',
        'platform': 'Platforms and infrastructure',
        'integration': 'Cross-cutting patterns and integrations',
        'domain': 'Domain-specific knowledge and practices',
    }
    
    def __init__(self):
        self.categories = defaultdict(set)
        self.skill_metadata = {}
    
    def catalog_skill(self, name: str, category: str, 
                       layer: str, tags: List[str]):
        self.skill_metadata[name] = {
            'category': category,
            'layer': layer,
            'tags': tags,
            'related': [],
        }
        self.categories[category].add(name)
    
    def portfolio_balance(self) -> Dict:
        """Analyze distribution across ecosystem layers."""
        layer_counts = defaultdict(int)
        for meta in self.skill_metadata.values():
            layer_counts[meta['layer']] += 1
        
        total = sum(layer_counts.values()) or 1
        return {
            layer: {
                'count': count,
                'pct': round(count / total * 100, 1),
            }
            for layer, count in sorted(layer_counts.items())
        }
    
    def coverage_gaps(self) -> List[str]:
        """Find underrepresented ecosystem layers."""
        balance = self.portfolio_balance()
        gaps = []
        for layer, expected in {'foundation': 15, 'language': 20, 
                                 'framework': 30, 'domain': 15}.items():
            actual = balance.get(layer, {}).get('pct', 0)
            if actual < expected:
                gaps.append(f"{layer}: {actual}% (target {expected}%)")
        return gaps

Taxonomy Principles

TAXONOMY_PRINCIPLES = {
    'mutual_exclusivity': 'A skill belongs to exactly one primary category',
    'hierarchical_depth': 'Max 3 levels deep (Cat → Subcat → Skill)',
    'consistent_naming': 'Nouns for categories, verb-phrases for skill descriptions',
    'future_room': 'Categories should allow growth without restructuring',
    'user_mental_model': 'Categories match how users think about the domain',
}

Common Pitfalls

1. Over-categorization — too many small categories make navigation harder
2. Inconsistent naming — some categories are technology names, others are concepts
3. Skills in multiple categories — confusion about where a skill lives
4. No cross-links — categories are silos; cross-reference between categories
5. Rigid taxonomy — categories don't evolve with new technologies

Verification Checklist

• Category names are consistent and self-explanatory
• Each skill maps to exactly one primary category
• Cross-category navigation links exist
• Category balance is healthy (no single category > 50%)
• Taxonomy allows room for 2x growth
• User can find a skill in ≤3 clicks
• Categories reviewed and updated annually