skill-creator-expert

What this skill does

# Skill Creator Expert

Master skill architect for designing, implementing, and validating high-quality PCL skills. Specializes in domain knowledge extraction, skill composition patterns, and PCL best practices.

## Core Competencies

### Skill Design Principles

- Domain analysis and knowledge extraction
- Skill scope definition and boundaries
- Dependency mapping and composition
- Tool allowlist configuration
- Version management and evolution

### Skill Architecture Patterns

- Single-responsibility skills
- Composite skills (orchestration)
- Hierarchical skill structures
- Cross-domain skill integration
- Reusable skill components

### Quality & Validation

- Skill testing frameworks
- Documentation completeness
- Example scenario coverage
- Performance benchmarking
- Security review

## Skill Creation Framework

### 1. Domain Analysis Template

```typescript
interface DomainAnalysis {
  // Core domain identification
  domain: {
    name: string;
    category:
      | 'language'
      | 'framework'
      | 'cloud'
      | 'data'
      | 'devops'
      | 'ai'
      | 'security'
      | 'professional'
      | 'scientific'
      | 'tools'
      | 'domains';
    subcategories: string[];
    relatedDomains: string[];
  };

  // Knowledge extraction
  coreKnowledge: {
    fundamentals: string[];
    advancedConcepts: string[];
    bestPractices: string[];
    antiPatterns: string[];
    commonPitfalls: string[];
  };

  // Practical expertise
  practicalSkills: {
    codePatterns: CodePattern[];
    architecturePatterns: ArchitecturePattern[];
    toolingExpertise: string[];
    debuggingStrategies: string[];
    optimizationTechniques: string[];
  };

  // Real-world scenarios
  useCases: {
    beginner: Scenario[];
    intermediate: Scenario[];
    advanced: Scenario[];
    expert: Scenario[];
  };

  // Integration points
  dependencies: {
    required: string[];
    optional: string[];
    complementary: string[];
  };
}

interface CodePattern {
  name: string;
  context: string;
  problem: string;
  solution: string;
  example: string;
  alternatives: string[];
}

interface ArchitecturePattern {
  name: string;
  applicability: string;
  structure: string;
  implementation: string;
  consequences: {
    benefits: string[];
    tradeoffs: string[];
  };
}

interface Scenario {
  title: string;
  context: string;
  challenge: string;
  approach: string;
  codeExample: string;
  explanation: string;
}
```

### 2. Skill Structure Generator

```typescript
class SkillStructureGenerator {
  /**
   * Generate complete skill structure from domain analysis
   */
  generateSkill(analysis: DomainAnalysis): SkillDefinition {
    return {
      metadata: this.generateMetadata(analysis),
      frontMatter: this.generateFrontMatter(analysis),
      coreConcepts: this.extractCoreConcepts(analysis),
      codeExamples: this.generateCodeExamples(analysis),
      bestPractices: this.compileBestPractices(analysis),
      advancedPatterns: this.extractAdvancedPatterns(analysis),
      integrationGuide: this.generateIntegrationGuide(analysis),
      troubleshooting: this.generateTroubleshooting(analysis),
      references: this.gatherReferences(analysis),
    };
  }

  /**
   * Generate YAML front matter
   */
  private generateFrontMatter(analysis: DomainAnalysis): string {
    const tools = this.determineRequiredTools(analysis);
    const tags = this.extractRelevantTags(analysis);

    return `---
name: ${analysis.domain.name}
version: 1.0.0
description: ${this.generateDescription(analysis)}
category: ${analysis.domain.category}
tags: [${tags.join(', ')}]
allowed-tools:
${tools.map((t) => `  - ${t}`).join('\n')}
---`;
  }

  /**
   * Extract and organize core concepts
   */
  private extractCoreConcepts(analysis: DomainAnalysis): Section {
    return {
      title: 'Core Concepts',
      subsections: [
        {
          title: 'Fundamentals',
          content: this.formatFundamentals(analysis.coreKnowledge.fundamentals),
        },
        {
          title: 'Advanced Concepts',
          content: this.formatAdvancedConcepts(
            analysis.coreKnowledge.advancedConcepts
          ),
        },
        {
          title: 'Best Practices',
          content: this.formatBestPractices(
            analysis.coreKnowledge.bestPractices
          ),
        },
      ],
    };
  }

  /**
   * Generate comprehensive code examples
   */
  private generateCodeExamples(analysis: DomainAnalysis): Section {
    const examples: CodeExample[] = [];

    // Extract patterns by complexity
    for (const level of [
      'beginner',
      'intermediate',
      'advanced',
      'expert',
    ] as const) {
      const scenarios = analysis.useCases[level];
      scenarios.forEach((scenario) => {
        examples.push({
          title: scenario.title,
          level,
          code: scenario.codeExample,
          explanation: scenario.explanation,
          context: scenario.context,
        });
      });
    }

    return this.formatCodeExamplesSection(examples);
  }

  /**
   * Compile best practices with rationale
   */
  private compileBestPractices(analysis: DomainAnalysis): Section {
    const practices = analysis.coreKnowledge.bestPractices.map((practice) => ({
      practice,
      rationale: this.extractRationale(practice, analysis),
      examples: this.findExamples(practice, analysis),
      antiPatterns: this.findRelatedAntiPatterns(practice, analysis),
    }));

    return {
      title: 'Best Practices',
      content: this.formatBestPracticesWithContext(practices),
    };
  }

  /**
   * Extract advanced patterns and architectures
   */
  private extractAdvancedPatterns(analysis: DomainAnalysis): Section {
    return {
      title: 'Advanced Patterns',
      subsections: analysis.practicalSkills.architecturePatterns.map(
        (pattern) => ({
          title: pattern.name,
          content: this.formatArchitecturePattern(pattern),
        })
      ),
    };
  }

  /**
   * Generate integration guide
   */
  private generateIntegrationGuide(analysis: DomainAnalysis): Section {
    const integrations = this.analyzeIntegrations(analysis);

    return {
      title: 'Integration Guide',
      subsections: [
        {
          title: 'Required Dependencies',
          content: this.formatDependencies(analysis.dependencies.required),
        },
        {
          title: 'Optional Integrations',
          content: this.formatOptionalIntegrations(
            analysis.dependencies.optional
          ),
        },
        {
          title: 'Complementary Skills',
          content: this.formatComplementarySkills(
            analysis.dependencies.complementary
          ),
        },
        {
          title: 'Integration Patterns',
          content: this.formatIntegrationPatterns(integrations),
        },
      ],
    };
  }

  /**
   * Generate troubleshooting guide
   */
  private generateTroubleshooting(analysis: DomainAnalysis): Section {
    const issues = this.extractCommonIssues(analysis);

    return {
      title: 'Troubleshooting',
      content: issues.map((issue) => this.formatTroubleshootingItem(issue)),
    };
  }

  /**
   * Gather comprehensive references
   */
  private gatherReferences(analysis: DomainAnalysis): Section {
    return {
      title: 'References',
      subsections: [
        {
          title: 'Official Documentation',
          content: this.findOfficialDocs(analysis.domain.name),
        },
        {
          title: 'Community Resources',
          content: this.findCommunityResources(analysis.domain.name),
        },
        {
          title: 'Related Skills',
          content: analysis.domain.relatedDomains
            .map((d) => `- ${d}`)
            .join('\n'),
        },
      ],
    };
  }
}
```

### 3. Skill Validation Engine

```typescript
class SkillValidator {
  /**
   * Comprehensive skill validation
   */
  validate(skill: SkillDefinition): ValidationReport {
    const checks: ValidationCheck[] = [
      thi