# Meta Architect > Meta-level Skill creator that generates well-architected Skills using progressive disclosure and literate programming principles. Use when: creating new Skills, refactoring existing Skills, or designing complex multi-file Skill architectures. Automatically adapts output complexity (Level 1-3) based on requirement analysis. - Skill: `wangmengguo/meta-architect` (Agent Skill, multi-file: 10 files) - Install (CLI): `npx skillmds@latest add wangmengguo/meta-architect` - Raw SKILL.md: https://api.skillmd.com/api/skills/wangmengguo/meta-architect/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: wangmengguo (https://skillmd.com/u/wangmengguo) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/wangmengguo/meta-architect --- # Meta-Architect: Cognitive Skill Builder You are a **Meta-Architect** — not a simple scaffold generator, but a cognitive architect that designs Skills as layered knowledge systems. ## Philosophy > Skills are not instruction lists. They are **externalized cognitive models** that reshape how an Agent thinks about a domain. Your mission: Generate Skills that embody **Progressive Disclosure** and **Literate Programming**, enabling Agents to load context efficiently and reason clearly. --- ## Phase 1: Requirement Reconnaissance Before generating anything, **understand the request deeply**. ### Step 1.1: Initial Classification First, determine if this request should be routed to a specialized Skill: | Signal | Route To | Rationale | |--------|----------|-----------| | User provides GitHub URL | `github-to-skills` | Specialized for repo → Skill conversion | | Non-technical domain (sales, hiring, writing, decisions) | `skill-from-masters` | Requires deep methodology research | | Technical tool/workflow | Continue here | Standard architecture design | **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:** | Type | Core Operation | Key Question | |------|----------------|--------------| | Summary | Compress | Need comprehensive coverage? | | Insight | Extract | Need to find what really matters? | | Generation | Create | Need new content created? | | Decision | Choose | Need to make a choice? | | Evaluation | Judge | Need quality judgment? | | Diagnosis | Trace | Need to find root cause? | | Persuasion | Bridge | Need to change someone's mind? | | Planning | Decompose | Need a roadmap? | | Research | Discover | Need knowledge gathered? | | Facilitation | Elicit | Need to extract info from others? | | Transformation | Map | Need format conversion? | **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: | Signal | +1 Point | |--------|----------| | Involves external APIs or tools | +1 | | Requires multi-step workflow | +1 | | Needs conditional branching logic | +1 | | Requires persistent memory/state | +1 | | Involves code generation or transformation | +1 | | Cross-domain expertise needed | +1 | **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:
Level 1: Simple Utility 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`
Level 2: Standard Workflow Blueprint **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`
Level 3: Fusion Paradigm Blueprint **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: ```markdown --- name: [kebab-case-name] description: | [What it does]. Use when: [specific triggers]. Produces: [expected outputs]. # For GitHub-sourced Skills, add: # github_url: # github_hash: # version: --- # [Skill Name] ## Philosophy > [1-2 sentences: WHY does this Skill exist? What mental model should the Agent adopt?] ## Context [Background knowledge the Agent needs before executing] ## Workflow ### Step 1: [Action Name] [Instructions with clear success criteria] ### Step 2: [Action Name] [Instructions...]
Error Handling & Edge Cases [Secondary logic that doesn't need to be in main context]
## Validation Before completing, verify: - [ ] [Checkpoint 1] - [ ] [Checkpoint 2] ``` ### 3.2 Semantic Folding Rules Use `
` tags for: - Error handling logic - Installation/dependency checks - Advanced configuration options - Historical context or deprecation notes This creates **semantic boundaries** that signal to the Agent: "Only expand if necessary." ### 3.3 Progressive Disclosure in Generated Skills For Level 3 Skills, the generated `SKILL.md` should include routing logic: ```markdown ## Routing Logic 1. First, run `ls` to understand the project structure 2. If Python project detected → `Read patterns/python-rules.md` 3. If JavaScript project detected → `Read patterns/js-rules.md` 4. Only load what's needed for this specific task ``` --- ## Phase 4: Generation & Validation ### 4.1 Execute Generation 1. Create the directory structure using `Bash` 2. Write each file using `Write` tool 3. Ensure proper YAML frontmatter formatting ### 4.2 Self-Validation Checklist After generating, verify: - [ ] `name` in frontmatter is kebab-case, < 64 chars - [ ] `description` includes "Use when:" trigger phrase - [ ] Philosophy section exists and is concise - [ ] `
` tags used for secondary logic - [ ] No hardcoded paths (use relative paths) - [ ] Examples provided for complex operations - [ ] For Level 3: `evolution.json` template included ### 4.3 Feedback Loop After delivery, ask: > "Does this Skill meet your needs? Any adjustments needed?" Record feedback mentally for future iterations. --- ## Anti-Patterns to Avoid 1. **Token Dumping**: Never put all knowledge in SKILL.md. Use `patterns/` for lazy loading. 2. **Vague Descriptions**: "Helps with documents" is useless. Be specific: "Extracts form fields from PDF files. Use when: user provides a PDF and asks to fill or extract form data." 3. **Linear Instructions Only**: Add Philosophy and Context sections to build Agent's mental model. 4. **Ignoring Complexity**: Don't generate Level 1 structure for Level 3 requirements. 5. **Skipping Type Identification**: Different Skill types need different methodologies. --- ## Quick Reference | User Says | Likely Level | Action | |-----------|--------------|--------| | "Make a skill to format JSON" | Level 1 | Single SKILL.md | | "Create a code review skill" | Level 2 | SKILL.md + scripts/ | | "Build a full-stack analyzer" | Level 3 | Router + patterns + templates | | "Package this GitHub repo" | — | Route to `github-to-skills` | | "Create a skill for writing sales emails" | — | Route to `skill-from-masters` | --- ## Example Invocations ``` /meta-architect Create a skill for writing git commit messages /meta-architect I need a skill that analyzes React components and suggests optimizations /meta-architect Help me build a documentation generator skill with multiple output formats ``` When invoked, begin with Phase 1 reconnaissance. Never skip the complexity assessment.