Meta Architect

Route Command:

For GitHub repos: "This looks like a GitHub-sourced Skill. Let me use `github-to-skills` for optimal conversion."
→ Read ~/.config/opencode/skills/github-to-skills/SKILL.md

For non-technical Skills: "This is a non-technical Skill that needs expert methodology research. Let me use `skill-from-masters`."
→ Read ~/.config/opencode/skills/skill-from-masters/SKILL.md

Step 1.2: Scope Check — Is It Narrow Enough?

Before proceeding, verify the request is specific enough. If unclear, use the 5-Layer Narrowing Framework:

Read knowledge/narrowing-framework.md

Quick Check Questions:

1. Can you describe the Skill in one sentence with specific role, context, and output type?
2. Would experts in this specific scenario have unique advice (not generic)?
3. Are there context-specific rules, tradeoffs, or failure modes?

If ANY answer is "No" → Apply narrowing framework before continuing.

Step 1.3: Skill Type Identification

Identify the core cognitive operation this Skill performs:

Read knowledge/skill-taxonomy.md

Quick Reference:

Confirm with user: "This sounds like a [Type] Skill—the goal is to [core operation]. Is that right?"

Step 1.4: Complexity Assessment

Analyze the request and score it:

Complexity Level:

• Level 1 (0-1 points): Simple utility — single SKILL.md file
• Level 2 (2-3 points): Standard workflow — SKILL.md + scripts/
• Level 3 (4+ points): Fusion paradigm — Router + patterns/ + templates/

Step 1.5: Clarifying Questions (if needed)

If the request is still ambiguous after type identification:

1. What is the single most important outcome this Skill should produce?
2. Should this Skill be user-invoked (/skill-name) or agent-invoked (automatic)?
3. Are there existing tools or scripts that should be wrapped?
4. What failure modes should be handled explicitly?

Phase 2: Architecture Selection

Based on complexity level, load the appropriate blueprint:

Structure:

my-skill/
└── SKILL.md

Characteristics:

• Single file, < 200 lines
• Inline instructions, no external dependencies
• Direct execution pattern

Use Read tool to load: blueprints/level1_utility/template.md

Structure:

my-skill/
├── SKILL.md           # Core logic + philosophy
├── scripts/           # Executable Python/Bash
│   └── main.py
└── examples/          # Sample inputs/outputs
    └── example.json

Characteristics:

• Separation of concerns
• Deterministic scripts for repeatable operations
• Examples for Agent learning

Use Read tool to load: blueprints/level2_workflow/template.md

Structure:

my-skill/
├── SKILL.md           # Router + Philosophy (lightweight)
├── patterns/          # Domain knowledge (lazy-loaded)
│   ├── scenario_a.md
│   └── scenario_b.md
├── templates/         # Output templates
│   └── output.md
├── scripts/           # Executable code
│   └── processor.py
├── memory/            # Persistent learnings (optional)
│   └── feedback.md
└── evolution.json     # Experience persistence (for lifecycle management)

Characteristics:

• SKILL.md is a router, not a knowledge dump
• Patterns are loaded only when needed
• Supports recursive self-improvement via memory/
• evolution.json preserves learnings across updates

Use Read tool to load: blueprints/level3_fusion/template.md

Phase 3: Literate Construction

Generate Skills following Literate Programming principles.

3.1 Mandatory Structure for Generated SKILL.md

Every generated Skill MUST include these sections:

---