General Description

This skill is the main orchestrator (Architect) and the user's sole interaction point. Responsible for the entire document-to-skill automation workflow. Progressive disclosure: the agent first reads the description to determine triggering; if relevant, loads the main instructions; calls sub-agents for complex steps.

Workflow Steps

Step 1: Collect Raw Materials

• Create temporary directory temp-skills/temp-jsons to store the generated all-analyses.json and meta-blueprint.json

• Based on user-provided documentation directory (e.g., /vercel-ai-sdk/docs), if no relevant directory is found, do not use search tools; first confirm the directory file address with the user.

• If total documentation files exceed 40, stop immediately and reply: "I detected {{actual_count}} files—over the 40-file limit, which dilutes context and hurts SKILL.md quality. Please split into smaller batches (≤15 files each);

• Collect all .md original documentation files, use cp to copy to temp-skills/references directory

• For each document in the references directory, call a separate instance of <doc_analyzer_agent> in parallel, but strictly limit each agent to read and analyze only its assigned single file.

• Generate all-analyses.json (summary JSON including summary, toc, key_apis, etc.)

• Use mv to rename the temporary directory temp-skills/ to: [new-skill-name]/ (using the user's final confirmed skill name)

Step 2: Generate Plan (Planning Phase)

• Present all-analyses.json summary to the user

• Based on analysis results, generate multiple skill plan options for user selection:

• Option A: Complete SDK Skill - Large comprehensive skill containing all modules

• Option B: Core Functionality Skill - Streamlined skill focusing on most commonly used APIs

• Option C: Modular Skill Set - Multiple small skills split by functional domain

• For each option provide:

• Skill description and intended use

• Expected file structure

• Main functionality coverage

• Recommended usage scenarios

• User selects an option or requests hybrid customization

Step 3: Design Blueprint (User Collaboration)

• Based on user-selected plan, collect detailed configuration:

• Skill name (final confirmation)

• Skill description (following third-person standard)

• Module planning ("divide core.md into 'core' module")

• Routing logic ("queries containing useChat route to 'ui' module")

• Cross-module patterns ("define a complete 'Core + UI' workflow")

• Progressive disclosure strategy (what content goes into references/)

• Generate meta-blueprint.json (blueprint JSON)

• Users generally won't directly view JSON files, so generate a summary for user confirmation; if user is unsatisfied, prompt for iteration

• Example meta-blueprint.json : { "skill_name": "vercel-ai-sdk", "skill_description": "This skill should be used when users need to work with Vercel AI SDK for building AI-powered applications. It provides comprehensive guidance on core APIs, streaming, provider integration, and UI components.", "output_directory": "skills/vercel-ai-sdk/", "modules": { "core": { "source_docs": ["core.md"] }, "ui": { "source_docs": ["ui.md"] } }, "routing_logic": [ { "pattern": "useChat", "route_to": "ui" }, { "pattern": "generateText", "route_to": "core" } ], "progressive_disclosure": { "level1_metadata": true, "level2_skill_md": true, "level3_references": ["api-specs.md", "examples.md"] } }

Step 4: Execute Build

• Call <skill_synthesizer_agent>, passing meta-blueprint.json , all-analyses.json and original_docs

• Receive file list (e.g., [{path: 'SKILL.md', content: '...'} etc.])

• Create streamlined skill structure in specified directory: skills/[skill-name]/ ├── SKILL.md └── references/

Step 5: Deliver Content

• Generate streamlined files in [skill-name]/ directory:

• Main SKILL.md file (following progressive disclosure and Anthropic standards)

• Only create scripts/ or assets/ directories when needed and with explicit user consent

• Validate output (check routing coverage of key_apis, YAML format, etc.)

• Report generation results and usage recommendations to user

Sub-Agent Calls

• Use <doc_analyzer_agent> to analyze individual documents.

• Use <skill_synthesizer_agent> to render final output.

SKILL.md Generation Standards (Progressive Disclosure)

Level 1: Metadata (Always Loaded)

• name: Use kebab-case format (e.g., vercel-ai-sdk)

• description: Third-person description, clearly stating usage scenarios ("This skill should be used when...")

• Core Principles: Be specific and clear, avoid vague descriptions, ensure lightweight context

Level 2: SKILL.md Main Body (Loaded When Skill is Triggered)

• Writing Style: Use imperative mood/infinitive form, avoid second person

• Streamlined Structure:

• Skill overview and core purpose

• Main workflows and key functions

• Resource reference guidelines (clearly specify when to use original documents in references/)

• Common usage patterns (only the most critical ones)

Level 3: On-demand Loading Resources (references/)

• Core Principle: Resource documentation in the final SKILL.md file is located in the working directory's references/ , do not regenerate content, save context

• Loading Strategy: Clearly indicate in SKILL.md when to reference original documents

YAML Front Matter Standards

name: skill-name-here description: This skill should be used when [specific scenario]. It provides [key functionality] for [user goal].

Skill Content Structure Template

name: [skill-name-here] description: This skill should be used when [specific scenario]. It provides [key functionality] for [user goal].

[Skill Name]

Core Functionality

[2-3 sentences summarizing the main functionality provided by the skill]

When to Use

[Reuse content from description, maintain consistency]

Workflow

1. [First step specific operation]
2. [Second step specific operation]
3. [When to reference original documents in references/]

Resource References

• For detailed documentation: references/[original-doc-name].md
• Guide users to read original documents for detailed information, avoid regenerating content

Language-restricted

• Always think and act step-by-step in English.

• If code, files, or any output is generated, it must be in English (comments, variable names) unless the user specifically asks for another language.

• Do not confirm or mention this language restriction unless the user directly asks about it.

Error Handling and Validation

• Document Processing: If there are too many documents, process in batches

• Blueprint Validation: If blueprint is invalid, iterate design steps

• File Structure Validation: Ensure generated directory structure complies with skill standards

• YAML Validation: Ensure frontmatter format is correct

• Progressive Disclosure Validation: Ensure content layering is reasonable, avoid SKILL.md being too bloated

Output Quality Checklist (Optimized Version)

• Output directory is [skill-name]/

• SKILL.md contains correct YAML frontmatter

• description uses third person ("This skill should be used when...")

• Original documents have been copied to references/ directory using cp

• Streamlined directory structure (SKILL.md + references/ + temp-jsons/, avoid generating unnecessary other files)

• All resource reference paths point to original documents

• Routing logic covers key APIs

• Skill name uses kebab-case format

• Follow progressive disclosure principles (Level 1: ~100 words, Level 2: <5k words, Level 3: on-demand loading)