// Meta-skill for creating new Claude Code skills with configurable execution modes. Supports sequential (fixed order) and autonomous (stateless) phase patterns. Use for skill scaffolding, skill creation, or building new workflows. Triggers on "create skill", "new skill", "skill generator".
Generate software copyright design specification documents compliant with China Copyright Protection Center (CPCC) standards. Creates complete design documents with Mermaid diagrams based on source code analysis. Use for software copyright registration, generating design specification, creating CPCC-compliant documents, or documenting software for intellectual property protection. Triggers on "软件著作权", "设计说明书", "版权登记", "CPCC", "软著申请".
Multi-phase iterative project analysis with Mermaid diagrams. Generates architecture reports, design reports, method analysis reports. Use when analyzing codebases, understanding project structure, reviewing architecture, exploring design patterns, or documenting system components. Triggers on "analyze project", "architecture report", "design analysis", "code structure", "system overview".
Universal skill diagnosis and optimization tool. Detect and fix skill execution issues including context explosion, long-tail forgetting, data flow disruption, and agent coordination failures. Supports Gemini CLI for deep analysis. Triggers on "skill tuning", "tune skill", "skill diagnosis", "optimize skill", "skill debug".
Generate interactive TiddlyWiki-style HTML software manuals with screenshots, API docs, and multi-level code examples. Use when creating user guides, software documentation, or API references. Triggers on "software manual", "user guide", "generate manual", "create docs".
Meta-skill for designing orchestrator+phases structured workflow skills. Creates SKILL.md coordinator with progressive phase loading, TodoWrite patterns, and data flow. Triggers on "design workflow skill", "create workflow skill", "workflow skill designer".
| name | skill-generator |
| description | Meta-skill for creating new Claude Code skills with configurable execution modes. Supports sequential (fixed order) and autonomous (stateless) phase patterns. Use for skill scaffolding, skill creation, or building new workflows. Triggers on "create skill", "new skill", "skill generator". |
| allowed-tools | Task, AskUserQuestion, Read, Bash, Glob, Grep, Write |
Meta-skill for creating new Claude Code skills with configurable execution modes.
┌─────────────────────────────────────────────────────────────────┐
│ Skill Generator │
│ │
│ Input: User Request (skill name, purpose, mode) │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Phase 0-5: Sequential Pipeline │ │
│ │ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │ │
│ │ │ P0 │→│ P1 │→│ P2 │→│ P3 │→│ P4 │→│ P5 │ │ │
│ │ │Spec│ │Req │ │Dir │ │Gen │ │Spec│ │Val │ │ │
│ │ └────┘ └────┘ └────┘ └─┬──┘ └────┘ └────┘ │ │
│ │ │ │ │
│ │ ┌────┴────┐ │ │
│ │ ↓ ↓ │ │
│ │ Sequential Autonomous │ │
│ │ (phases/) (actions/) │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ Output: .claude/skills/{skill-name}/ (complete package) │
│ │
└─────────────────────────────────────────────────────────────────┘
Traditional linear execution model, phases execute in numeric prefix order.
Phase 01 -> Phase 02 -> Phase 03 -> ... -> Phase N
Use Cases:
Examples: software-manual, copyright-docs
Intelligent routing model, dynamically selects execution path based on context.
---------------------------------------------------
Orchestrator Agent
(Read state -> Select Phase -> Execute -> Update)
---------------------------------------------------
|
---------+----------+----------
| | |
Phase A Phase B Phase C
(standalone) (standalone) (standalone)
Use Cases:
Examples: issue-manage, workflow-debug
_shared/SKILL-DESIGN-SPEC.mdIMPORTANT: Before any generation operation, read the following specification documents. Generating without understanding these standards will result in non-conforming output.
| Document | Purpose | Priority |
|---|---|---|
| ../_shared/SKILL-DESIGN-SPEC.md | Universal design spec - defines structure, naming, quality standards for all Skills | P0 - Critical |
| specs/reference-docs-spec.md | Reference document generation spec - ensures generated Skills have proper phase-based Reference Documents with usage timing guidance | P0 - Critical |
| Document | Purpose |
|---|---|
| templates/skill-md.md | SKILL.md entry file template |
| templates/sequential-phase.md | Sequential Phase template |
| templates/autonomous-orchestrator.md | Autonomous Orchestrator template |
| templates/autonomous-action.md | Autonomous Action template |
| templates/code-analysis-action.md | Code Analysis Action template |
| templates/llm-action.md | LLM Action template |
| templates/script-template.md | Unified Script Template (Bash + Python) |
| Document | Purpose |
|---|---|
| specs/execution-modes.md | Execution Modes Specification |
| specs/skill-requirements.md | Skill Requirements Specification |
| specs/cli-integration.md | CLI Integration Specification |
| specs/scripting-integration.md | Script Integration Specification |
| Document | Purpose |
|---|---|
| phases/01-requirements-discovery.md | Collect Skill Requirements |
| phases/02-structure-generation.md | Generate Directory Structure |
| phases/03-phase-generation.md | Generate Phase Files |
| phases/04-specs-templates.md | Generate Specs and Templates |
| phases/05-validation.md | Validation and Documentation |
Input Parsing:
└─ Convert user request to structured format (skill-name/purpose/mode)
Phase 0: Specification Study (MANDATORY - Must complete before proceeding)
- Read specification documents
- Load: ../_shared/SKILL-DESIGN-SPEC.md
- Load: All templates/*.md files
- Understand: Structure rules, naming conventions, quality standards
- Output: Internalized requirements (in-memory, no file output)
- Validation: MUST complete before Phase 1
Phase 1: Requirements Discovery
- Gather skill requirements via user interaction
- Tool: AskUserQuestion
- Collect: Skill name, purpose, execution mode
- Collect: Phase/Action definition
- Collect: Tool dependencies, output format
- Process: Generate configuration object
- Output: skill-config.json
- Contains: skill_name, execution_mode, phases/actions, allowed_tools
Phase 2: Structure Generation
- Create directory structure and entry file
- Input: skill-config.json (from Phase 1)
- Tool: Bash
- Execute: mkdir -p .claude/skills/{skill-name}/{phases,specs,templates,scripts}
- Tool: Write
- Generate: SKILL.md (entry point with architecture diagram)
- Output: Complete directory structure
Phase 3: Phase/Action Generation
- Decision (execution_mode check):
- IF execution_mode === "sequential": Generate Sequential Phases
- Read template: templates/sequential-phase.md
- Loop: For each phase in config.sequential_config.phases
- Generate: phases/{phase-id}.md
- Link: Previous phase output -> Current phase input
- Write: phases/_orchestrator.md
- Write: workflow.json
- Output: phases/01-{name}.md, phases/02-{name}.md, ...
- ELSE IF execution_mode === "autonomous": Generate Orchestrator + Actions
- Read template: templates/autonomous-orchestrator.md
- Write: phases/state-schema.md
- Write: phases/orchestrator.md
- Write: specs/action-catalog.md
- Loop: For each action in config.autonomous_config.actions
- Read template: templates/autonomous-action.md
- Generate: phases/actions/{action-id}.md
- Output: phases/orchestrator.md, phases/actions/*.md
Phase 4: Specs & Templates
- Generate domain specifications and templates
- Input: skill-config.json (domain context)
- Reference: [specs/reference-docs-spec.md](specs/reference-docs-spec.md) for document organization
- Tool: Write
- Generate: specs/{domain}-requirements.md
- Generate: specs/quality-standards.md
- Generate: templates/agent-base.md (if needed)
- Output: Domain-specific documentation
Phase 5: Validation & Documentation
- Verify completeness and generate usage guide
- Input: All generated files from previous phases
- Tool: Glob + Read
- Check: Required files exist and contain proper structure
- Tool: Write
- Generate: README.md (usage instructions)
- Generate: validation-report.json (completeness check)
- Output: Final documentation
Execution Protocol:
// Phase 0: Read specifications (in-memory)
Read('.claude/skills/_shared/SKILL-DESIGN-SPEC.md');
Read('.claude/skills/skill-generator/templates/*.md'); // All templates
// Phase 1: Gather requirements
const answers = AskUserQuestion({
questions: [
{ question: "Skill name?", header: "Name", options: [...] },
{ question: "Execution mode?", header: "Mode", options: ["Sequential", "Autonomous"] }
]
});
const config = generateConfig(answers);
const workDir = `.workflow/.scratchpad/skill-gen-${timestamp}`;
Write(`${workDir}/skill-config.json`, JSON.stringify(config));
// Phase 2: Create structure
const skillDir = `.claude/skills/${config.skill_name}`;
Bash(`mkdir -p "${skillDir}/phases" "${skillDir}/specs" "${skillDir}/templates"`);
Write(`${skillDir}/SKILL.md`, generateSkillEntry(config));
// Phase 3: Generate phases (mode-dependent)
if (config.execution_mode === 'sequential') {
Write(`${skillDir}/phases/_orchestrator.md`, generateOrchestrator(config));
Write(`${skillDir}/workflow.json`, generateWorkflowDef(config));
config.sequential_config.phases.forEach(phase => {
Write(`${skillDir}/phases/${phase.id}.md`, generatePhase(phase, config));
});
} else {
Write(`${skillDir}/phases/orchestrator.md`, generateAutonomousOrchestrator(config));
Write(`${skillDir}/phases/state-schema.md`, generateStateSchema(config));
config.autonomous_config.actions.forEach(action => {
Write(`${skillDir}/phases/actions/${action.id}.md`, generateAction(action, config));
});
}
// Phase 4: Generate specs
Write(`${skillDir}/specs/${config.skill_name}-requirements.md`, generateRequirements(config));
Write(`${skillDir}/specs/quality-standards.md`, generateQualityStandards(config));
// Phase 5: Validate & Document
const validation = validateStructure(skillDir);
Write(`${skillDir}/validation-report.json`, JSON.stringify(validation));
Write(`${skillDir}/README.md`, generateReadme(config, validation));
IMPORTANT: This section demonstrates how skill-generator organizes its own reference documentation. This is the pattern that all generated Skills should emulate. See specs/reference-docs-spec.md for details.
Specification documents that must be read before any generation operation
| Document | Purpose | When to Use |
|---|---|---|
| ../_shared/SKILL-DESIGN-SPEC.md | Universal Skill design specification | Understand Skill structure and naming conventions - REQUIRED |
| specs/reference-docs-spec.md | Reference document generation specification | Ensure Reference Documents have proper phase-based organization - REQUIRED |
Collect Skill requirements and configuration
| Document | Purpose | When to Use |
|---|---|---|
| phases/01-requirements-discovery.md | Phase 1 execution guide | Understand how to collect user requirements and generate configuration |
| specs/skill-requirements.md | Skill requirements specification | Understand what information a Skill should contain |
Generate directory structure and entry file
| Document | Purpose | When to Use |
|---|---|---|
| phases/02-structure-generation.md | Phase 2 execution guide | Understand how to generate directory structure |
| templates/skill-md.md | SKILL.md template | Learn how to generate the entry file |
Generate specific phase or action files based on execution mode
| Document | Purpose | When to Use |
|---|---|---|
| phases/03-phase-generation.md | Phase 3 execution guide | Understand Sequential vs Autonomous generation logic |
| templates/sequential-phase.md | Sequential Phase template | Generate phase files for Sequential mode |
| templates/autonomous-orchestrator.md | Orchestrator template | Generate orchestrator for Autonomous mode |
| templates/autonomous-action.md | Action template | Generate action files for Autonomous mode |
Generate domain-specific specifications and templates
| Document | Purpose | When to Use |
|---|---|---|
| phases/04-specs-templates.md | Phase 4 execution guide | Understand how to generate domain-specific documentation |
| specs/reference-docs-spec.md | Reference document specification | IMPORTANT: Follow this spec when generating Specs |
Verify results and generate final documentation
| Document | Purpose | When to Use |
|---|---|---|
| phases/05-validation.md | Phase 5 execution guide | Understand how to verify generated Skill completeness |
Reference documents when encountering issues
| Issue | Solution Document |
|---|---|
| Generated Skill missing Reference Documents | specs/reference-docs-spec.md - verify phase-based organization is followed |
| Reference document organization unclear | specs/reference-docs-spec.md - Core Principles section |
| Generated documentation does not meet quality standards | ../_shared/SKILL-DESIGN-SPEC.md |
Documents for deep learning and design decisions
| Document | Purpose | Notes |
|---|---|---|
| specs/execution-modes.md | Detailed execution modes specification | Comparison and use cases for Sequential vs Autonomous |
| specs/cli-integration.md | CLI integration specification | How generated Skills integrate with CLI |
| specs/scripting-integration.md | Script integration specification | How to use scripts in Phases |
| templates/script-template.md | Script template | Unified Bash + Python template |
.claude/skills/{skill-name}/
├── SKILL.md # Entry file
├── phases/
│ ├── _orchestrator.md # Declarative orchestrator
│ ├── workflow.json # Workflow definition
│ ├── 01-{step-one}.md # Phase 1
│ ├── 02-{step-two}.md # Phase 2
│ └── 03-{step-three}.md # Phase 3
├── specs/
│ ├── {skill-name}-requirements.md
│ └── quality-standards.md
├── templates/
│ └── agent-base.md
├── scripts/
└── README.md
.claude/skills/{skill-name}/
├── SKILL.md # Entry file
├── phases/
│ ├── orchestrator.md # Orchestrator (state-driven)
│ ├── state-schema.md # State schema definition
│ └── actions/
│ ├── action-init.md
│ ├── action-create.md
│ └── action-list.md
├── specs/
│ ├── {skill-name}-requirements.md
│ ├── action-catalog.md
│ └── quality-standards.md
├── templates/
│ ├── orchestrator-base.md
│ └── action-base.md
├── scripts/
└── README.md
IMPORTANT: This section demonstrates how skill-generator organizes its own reference documentation. This is the pattern that all generated Skills should emulate. See specs/reference-docs-spec.md for details.
Specification documents that must be read before any generation operation
| Document | Purpose | When to Use |
|---|---|---|
| ../_shared/SKILL-DESIGN-SPEC.md | Universal Skill design specification | Understand Skill structure and naming conventions - REQUIRED |
| specs/reference-docs-spec.md | Reference document generation specification | Ensure Reference Documents have proper phase-based organization - REQUIRED |
Collect Skill requirements and configuration
| Document | Purpose | When to Use |
|---|---|---|
| phases/01-requirements-discovery.md | Phase 1 execution guide | Understand how to collect user requirements and generate configuration |
| specs/skill-requirements.md | Skill requirements specification | Understand what information a Skill should contain |
Generate directory structure and entry file
| Document | Purpose | When to Use |
|---|---|---|
| phases/02-structure-generation.md | Phase 2 execution guide | Understand how to generate directory structure |
| templates/skill-md.md | SKILL.md template | Learn how to generate the entry file |
Generate specific phase or action files based on execution mode
| Document | Purpose | When to Use |
|---|---|---|
| phases/03-phase-generation.md | Phase 3 execution guide | Understand Sequential vs Autonomous generation logic |
| templates/sequential-phase.md | Sequential Phase template | Generate phase files for Sequential mode |
| templates/autonomous-orchestrator.md | Orchestrator template | Generate orchestrator for Autonomous mode |
| templates/autonomous-action.md | Action template | Generate action files for Autonomous mode |
Generate domain-specific specifications and templates
| Document | Purpose | When to Use |
|---|---|---|
| phases/04-specs-templates.md | Phase 4 execution guide | Understand how to generate domain-specific documentation |
| specs/reference-docs-spec.md | Reference document specification | IMPORTANT: Follow this spec when generating Specs |
Verify results and generate final documentation
| Document | Purpose | When to Use |
|---|---|---|
| phases/05-validation.md | Phase 5 execution guide | Understand how to verify generated Skill completeness |
Reference documents when encountering issues
| Issue | Solution Document |
|---|---|
| Generated Skill missing Reference Documents | specs/reference-docs-spec.md - verify phase-based organization is followed |
| Reference document organization unclear | specs/reference-docs-spec.md - Core Principles section |
| Generated documentation does not meet quality standards | ../_shared/SKILL-DESIGN-SPEC.md |
Documents for deep learning and design decisions
| Document | Purpose | Notes |
|---|---|---|
| specs/execution-modes.md | Detailed execution modes specification | Comparison and use cases for Sequential vs Autonomous |
| specs/cli-integration.md | CLI integration specification | How generated Skills integrate with CLI |
| specs/scripting-integration.md | Script integration specification | How to use scripts in Phases |
| templates/script-template.md | Script template | Unified Bash + Python template |