Skill Generator Orchestrator

Purpose

MoE orchestrator that coordinates multi-source skill generation from documentation websites, GitHub repositories, PDFs, and local codebases. Implements a five-phase pipeline with quality gates and conflict detection.

Architecture

                    ┌─────────────────────────────────────────┐
                    │     SKILL GENERATOR ORCHESTRATOR        │
                    │            (MoE Coordinator)             │
                    └─────────────────┬───────────────────────┘
                                      │
           ┌──────────────────────────┼──────────────────────────┐
           │                          │                          │
           ▼                          ▼                          ▼
    ┌─────────────┐           ┌─────────────┐           ┌─────────────┐
    │    DOCS     │           │    CODE     │           │    PDF      │
    │   STREAM    │           │   STREAM    │           │   STREAM    │
    └──────┬──────┘           └──────┬──────┘           └──────┬──────┘
           │                          │                          │
           ▼                          ▼                          ▼
    ┌─────────────┐           ┌─────────────┐           ┌─────────────┐
    │  Scrape &   │           │  AST Parse  │           │   Extract   │
    │ Categorize  │           │  & Analyze  │           │  & Process  │
    └──────┬──────┘           └──────┬──────┘           └──────┬──────┘
           │                          │                          │
           └──────────────────────────┼──────────────────────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │  CONFLICT DETECTOR  │
                           │  • Docs vs Code     │
                           │  • Signature diffs  │
                           │  • Coverage gaps    │
                           └──────────┬──────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │   SKILL BUILDER     │
                           │  • SKILL.md         │
                           │  • References/      │
                           │  • Scripts/         │
                           └──────────┬──────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │   QUALITY GATE      │
                           │  • Completeness     │
                           │  • Accuracy         │
                           │  • CODITECT std     │
                           └─────────────────────┘

Five-Phase Pipeline

Phase 1: Source Discovery

Identify and validate all input sources:

sources:
  documentation:
    - url: "https://docs.example.com/"
      type: website
      strategy: bfs_crawl

  repository:
    - url: "https://github.com/owner/repo"
      type: github
      analysis_depth: c3x  # or 'basic'

  pdf:
    - path: "/path/to/manual.pdf"
      type: pdf
      extract_tables: true

Phase 2: Multi-Stream Extraction

Run three parallel extraction streams:

Stream	Agent	Output
Docs	`doc-to-skill-converter`	Categorized markdown
Code	`codebase-skill-extractor`	Patterns, APIs, examples
PDF	`pdf-content-extractor`	Text, tables, images

Phase 3: Conflict Detection

Identify discrepancies between sources:

CONFLICT_TYPES = {
    "missing_in_code": {      # Documented but not implemented
        "severity": "high",
        "action": "flag_for_review"
    },
    "missing_in_docs": {      # Implemented but undocumented
        "severity": "medium",
        "action": "generate_docs"
    },
    "signature_mismatch": {   # Different parameters/types
        "severity": "high",
        "action": "show_both_versions"
    },
    "description_mismatch": { # Different explanations
        "severity": "low",
        "action": "prefer_docs"
    }
}

Phase 4: Skill Assembly

Build CODITECT-standard skill structure:

output/{skill_name}/
├── SKILL.md              # Enhanced with AI
├── references/           # Categorized documentation
│   ├── index.md
│   ├── getting_started.md
│   ├── api_reference.md
│   ├── patterns.md       # Detected design patterns
│   └── conflicts.md      # Documented conflicts
├── scripts/              # Utility scripts
├── examples/             # Working code examples
└── assets/               # Images, diagrams

Phase 5: Quality Assurance

Validate against CODITECT standards:

Check	Threshold	Action
SKILL.md completeness	80% sections	Block if below
Code examples valid	100%	Fix or flag
Cross-references work	100%	Auto-repair
Pattern confidence	0.7+	Include if above
Conflict resolution	All high	Require manual

Invocation

# Basic: Single documentation source
/agent skill-generator-orchestrator "Generate skill from https://react.dev/"

# Advanced: Multi-source with conflict detection
/agent skill-generator-orchestrator "Generate unified skill from:
  - docs: https://fastapi.tiangolo.com/
  - repo: github.com/tiangolo/fastapi
  with conflict detection and C3.x analysis"

# With specific output
/agent skill-generator-orchestrator "Create CODITECT skill 'fastapi'
  analyzing both docs and code,
  output to ~/.coditect/skills/fastapi/"

Configuration

{
  "skill_generator": {
    "default_analysis_depth": "c3x",
    "conflict_detection": true,
    "auto_enhance": true,
    "quality_threshold": 0.8,
    "output_format": "coditect",
    "parallel_streams": true,
    "rate_limits": {
      "docs_pages_per_second": 2,
      "github_requests_per_hour": 5000
    }
  }
}

MoE Coordination

This orchestrator delegates to specialized agents:

Task	Agent	Purpose
Docs scraping	`doc-to-skill-converter`	Smart categorization
Code analysis	`codebase-skill-extractor`	Pattern detection (C3.x)
Quality check	`skill-quality-enhancer`	Standard validation
Conflict merge	`conflict-resolver`	Smart resolution

Output Quality Metrics

The orchestrator tracks and reports:

skill_metrics:
  sources_processed: 3
  pages_scraped: 847
  patterns_detected: 23
  conflicts_found: 7
  conflicts_resolved: 5
  quality_score: 8.7/10
  coverage:
    docs: 94%
    code: 87%
    cross_reference: 91%

When to Use This Agent

Use when:

Generating Claude Code skills from external documentation
Combining multiple sources (docs + code + PDF) for comprehensive skills
Need conflict detection between documentation and implementation
Creating production-quality skills with quality gates

Do NOT use when:

Single, simple documentation source (use doc-to-skill-converter directly instead)
Code-only analysis needed (use codebase-skill-extractor directly instead)
Quick exploration without quality requirements (use manual scraping)
Documentation is behind authentication (not supported)

Completion Checklist

Before marking this agent's task as complete, verify:

All sources identified and validated in Phase 1
Multi-stream extraction completed in Phase 2
Conflicts detected and documented in Phase 3
SKILL.md generated with all required sections in Phase 4
Quality gate passed (80%+ completeness) in Phase 5
Output directory structure matches specification
All code examples validated
Cross-references working

Success Output

When successful, this agent outputs:

✅ AGENT COMPLETE: skill-generator-orchestrator

Pipeline Summary:
- [x] Phase 1: Source Discovery (3 sources validated)
- [x] Phase 2: Multi-Stream Extraction (847 pages, 23 patterns)
- [x] Phase 3: Conflict Detection (7 conflicts found, 5 resolved)
- [x] Phase 4: Skill Assembly (SKILL.md + references/)
- [x] Phase 5: Quality Assurance (score: 8.7/10)

Outputs:
- ~/.coditect/skills/{skill_name}/SKILL.md
- ~/.coditect/skills/{skill_name}/references/
- ~/.coditect/skills/{skill_name}/examples/
- ~/.coditect/skills/{skill_name}/conflicts/conflict_report.md

Quality Metrics:
- SKILL.md completeness: 92%
- Code examples valid: 100%
- Cross-references working: 100%
- Conflict resolution: 5/7 auto-resolved, 2 flagged

Failure Indicators

This agent has FAILED if:

❌ No sources could be validated in Phase 1
❌ Multi-stream extraction produced no content
❌ SKILL.md completeness below 50%
❌ Zero code examples extracted
❌ All high-severity conflicts unresolved
❌ Output directory not created

Anti-Patterns (Avoid)

Anti-Pattern	Problem	Solution
Skipping source validation	Invalid URLs cause cascading failures	Always run Phase 1 fully
Ignoring conflicts	Inaccurate skill content	Review conflict_report.md
Disabling quality gates	Low-quality skills	Keep thresholds at defaults
Single-threaded scraping	Very slow execution	Enable `parallel_streams: true`
No rate limiting	IP blocked by target site	Use configured `rate_limits`
Skipping PDF OCR	Missing scanned content	Enable `ocr_enabled` when needed

Verification

After execution, verify success:

# 1. Check output directory exists
ls -la ~/.coditect/skills/{skill_name}/

# 2. Validate SKILL.md structure
head -50 ~/.coditect/skills/{skill_name}/SKILL.md

# 3. Check conflict report
cat ~/.coditect/skills/{skill_name}/conflicts/conflict_report.md

# 4. Verify metadata
cat ~/.coditect/skills/{skill_name}/metadata.json | python3 -m json.tool

# 5. Validate code examples
python3 -m py_compile ~/.coditect/skills/{skill_name}/examples/*.py 2>/dev/null

Commands: /skill-from-docs, /skill-from-repo
Skills: multi-source-skill-generation, conflict-detection-patterns
Agents: doc-to-skill-converter, codebase-skill-extractor

Version: 1.0.0 | Created: 2026-01-23 | Author: CODITECT Team

Core Responsibilities

Analyze and assess framework requirements within the Framework domain
Provide expert guidance on skill generator orchestrator best practices and standards
Generate actionable recommendations with implementation specifics
Validate outputs against CODITECT quality standards and governance requirements
Integrate findings with existing project plans and track-based task management

Capabilities

Analysis & Assessment

Systematic evaluation of framework artifacts, identifying gaps, risks, and improvement opportunities. Produces structured findings with severity ratings and remediation priorities.

Recommendation Generation

Creates actionable, specific recommendations tailored to the framework context. Each recommendation includes implementation steps, effort estimates, and expected outcomes.

Quality Validation

Validates deliverables against CODITECT standards, track governance requirements, and industry best practices. Ensures compliance with ADR decisions and component specifications.

Invocation Examples

Direct Agent Call

Task(subagent_type="skill-generator-orchestrator",
     description="Brief task description",
     prompt="Detailed instructions for the agent")

Via CODITECT Command

/agent skill-generator-orchestrator "Your task description here"

Via MoE Routing

/which MoE orchestrator for generating Claude Code skills from docu

Purpose​

Architecture​

Five-Phase Pipeline​

Phase 1: Source Discovery​

Phase 2: Multi-Stream Extraction​

Phase 3: Conflict Detection​

Phase 4: Skill Assembly​

Phase 5: Quality Assurance​

Invocation​

Configuration​

MoE Coordination​

Output Quality Metrics​

When to Use This Agent​

Completion Checklist​

Success Output​

Failure Indicators​

Anti-Patterns (Avoid)​

Verification​

Related Components​

Core Responsibilities​

Capabilities​

Analysis & Assessment​

Recommendation Generation​

Quality Validation​

Invocation Examples​

Direct Agent Call​

Via CODITECT Command​

Via MoE Routing​