Claude-Code-Workflow/docs/skills/claude-meta.md

Claude Skills - Meta-Skills

One-Liner

Meta-Skills is a tool system for creating and managing other skills — Through specification generation, skill generation, command generation, and help system, it enables sustainable development of the skill ecosystem.

Pain Points Solved

Pain Point	Current State	Claude_dms3 Solution
Complex skill creation	Manual skill structure and file creation	Automated skill generation
Missing specifications	Project specs scattered everywhere	Unified specification generation system
Difficult command discovery	Hard to find appropriate commands	Intelligent command recommendation and search
Tedious skill tuning	Skill optimization lacks guidance	Automated diagnosis and tuning

Skills List

Skill	Function	Trigger
spec-generator	Specification generator (6-stage document chain)	/spec-generator <idea>
brainstorm	Brainstorming (multi-role parallel analysis)	/brainstorm <topic>
skill-generator	Skill generator (meta-skill)	/skill-generator
skill-tuning	Skill tuning diagnosis	/skill-tuning <skill-name>
command-generator	Command generator	/command-generator
ccw-help	CCW command help system	/ccw-help
issue-manage	Issue management	/issue-manage

Skills Details

spec-generator

One-Liner: Specification generator — 6-stage document chain generates complete specification package (product brief, PRD, architecture, Epics)

Trigger:

/spec-generator <idea>
/spec-generator --continue        # Resume from checkpoint
/spec-generator -y <idea>        # Auto mode

Features:

• 6-stage document chain: Discovery → Requirements expansion → Product brief → PRD → Architecture → Epics → Readiness check
• Multi-perspective analysis: CLI tools (Gemini/Codex/Claude) provide product, technical, user perspectives
• Interactive defaults: Each stage provides user confirmation points; -y flag enables full auto mode
• Recoverable sessions: spec-config.json tracks completed stages; -c flag resumes from checkpoint
• Documentation only: No code generation or execution — clean handoff to existing execution workflows

Architecture Overview:

Phase 0:   Specification Study (Read specs/ + templates/ - mandatory prerequisite)
           |
Phase 1:   Discovery               -> spec-config.json + discovery-context.json
           |
Phase 1.5: Req Expansion           -> refined-requirements.json (interactive discussion + CLI gap analysis)
           |                           (-y auto mode: auto-expansion, skip interaction)
Phase 2:   Product Brief            -> product-brief.md  (multi-CLI parallel analysis)
           |
Phase 3:   Requirements (PRD)      -> requirements/  (_index.md + REQ-*.md + NFR-*.md)
           |
Phase 4:   Architecture            -> architecture/  (_index.md + ADR-*.md, multi-CLI review)
           |
Phase 5:   Epics & Stories         -> epics/  (_index.md + EPIC-*.md)
           |
Phase 6:   Readiness Check         -> readiness-report.md + spec-summary.md
           |
           Handoff to execution workflows

⚠️ Mandatory Prerequisites:

Do not skip: Before executing any operations, you must completely read the following documents.

Specification Documents (required):

Document	Purpose	Priority
specs/document-standards.md	Document format, frontmatter, naming conventions	P0 - Read before execution
specs/quality-gates.md	Quality gate standards and scoring per stage	P0 - Read before execution

Template Files (read before generation):

Document	Purpose
templates/product-brief.md	Product brief document template
templates/requirements-prd.md	PRD document template
templates/architecture-doc.md	Architecture document template
templates/epics-template.md	Epic/Story document template

Output Structure:

.workflow/.spec/SPEC-{slug}-{YYYY-MM-DD}/
├── spec-config.json              # Session config + stage status
├── discovery-context.json        # Codebase exploration results (optional)
├── refined-requirements.json     # Phase 1.5: Post-discussion confirmed requirements
├── product-brief.md              # Phase 2: Product brief
├── requirements/                 # Phase 3: Detailed PRD (directory)
│   ├── _index.md                 #   Summary, MoSCoW table, traceability, links
│   ├── REQ-NNN-{slug}.md         #   Single functional requirement
│   └── NFR-{type}-NNN-{slug}.md  #   Single non-functional requirement
├── architecture/                 # Phase 4: Architecture decisions (directory)
│   ├── _index.md                 #   Summary, components, tech stack, links
│   └── ADR-NNN-{slug}.md         #   Single architecture decision record
├── epics/                        # Phase 5: Epic/Story breakdown (directory)
│   ├── _index.md                 #   Epic table, dependency graph, MVP scope
│   └── EPIC-NNN-{slug}.md        #   Single Epic with Stories
├── readiness-report.md           # Phase 6: Quality report
└── spec-summary.md               # Phase 6: One-page executive summary

Handoff Options (after Phase 6 completion):

Option	Description
lite-plan	Extract first MVP Epic description → direct text input
plan / req-plan	Create WFS session + .brainstorming/ bridge file
issue:new	Create Issue for each Epic

---

brainstorm

One-Liner: Brainstorming — Interactive framework generation, multi-role parallel analysis, and cross-role synthesis

Trigger:

/brainstorm <topic>
/brainstorm --count 3 "Build platform"
/brainstorm -y "GOAL: Build SCOPE: Users" --count 5
/brainstorm system-architect --session WFS-xxx

Features:

• Dual-mode routing: Interactive mode selection, supports parameter auto-detection
• Auto mode: Phase 2 (artifacts) → Phase 3 (N×Role parallel) → Phase 4 (synthesis)
• Single Role mode: Phase 3 (1×Role analysis)
• Progressive phase loading: Phase files loaded on-demand via Ref: markers
• Session continuity: All phases share session state via workflow-session.json

Architecture Overview:

┌─────────────────────────────────────────────────────────────┐
│                    /brainstorm                                │
│         Unified Entry Point + Interactive Routing             │
└───────────────────────┬─────────────────────────────────────┘
                        │
              ┌─────────┴─────────┐
              ↓                   ↓
    ┌─────────────────┐  ┌──────────────────┐
    │   Auto Mode     │  │ Single Role Mode │
    │                 │  │                  │
    └────────┬────────┘  └────────┬─────────┘
             │                    │
    ┌────────┼────────┐          │
    ↓        ↓        ↓          ↓
 Phase 2  Phase 3  Phase 4    Phase 3
Artifacts  N×Role  Synthesis  1×Role
 (7 steps) Analysis  (8 steps) Analysis
           parallel             (4 steps)

Available Roles:

Role ID	Title	Focus Areas
data-architect	Data Architect	Data models, storage strategy, data flow
product-manager	Product Manager	Product strategy, roadmap, priorities
product-owner	Product Owner	Backlog management, user stories, acceptance criteria
scrum-master	Scrum Master	Process facilitation, impediment removal
subject-matter-expert	Subject Matter Expert	Domain knowledge, business rules, compliance
system-architect	System Architect	Technical architecture, scalability, integration
test-strategist	Test Strategist	Test strategy, quality assurance
ui-designer	UI Designer	Visual design, prototypes, design system
ux-expert	UX Expert	User research, information architecture, journeys

Output Structure:

.workflow/active/WFS-{topic}/
├── workflow-session.json              # Session metadata
├── .process/
│   └── context-package.json           # Phase 0 output (auto mode)
└── .brainstorming/
    ├── guidance-specification.md      # Framework (Phase 2, auto mode)
    ├── feature-index.json             # Feature index (Phase 4, auto mode)
    ├── synthesis-changelog.md         # Synthesis decision audit trail (Phase 4, auto mode)
    ├── feature-specs/                 # Feature specifications (Phase 4, auto mode)
    │   ├── F-001-{slug}.md
    │   └── F-00N-{slug}.md
    ├── {role}/                        # Role analysis (immutable after Phase 3)
    │   ├── {role}-context.md          # Interactive Q&A responses
    │   ├── analysis.md                # Main/index document
    │   ├── analysis-cross-cutting.md  # Cross-functional
    │   └── analysis-F-{id}-{slug}.md  # Per-feature
    └── synthesis-specification.md     # Synthesis (Phase 4, non-feature mode)

Core Rules:

1. Start with mode detection: First action is Phase 1 (parse params + detect mode)
2. Interactive routing: If mode cannot be determined from params, ASK user
3. No pre-analysis: Do not analyze topic before Phase 2
4. Parse every output: Extract required data from each stage
5. Auto-continue via TodoList: Check TodoList status to auto-execute next pending stage
6. Parallel execution: Auto mode Phase 3 simultaneously appends multiple agent tasks for concurrent execution

---

skill-generator

One-Liner: Skill generator — Meta-skill for creating new Claude Code Skills

Trigger:

/skill-generator
/create skill
/new skill

Features:

• Meta-skill for creating new Claude Code Skills
• Configurable execution modes: Sequential (fixed order) or Autonomous (stateless auto-selection)
• Use cases: Skill scaffolding, Skill creation, building new workflows

Execution Modes:

Mode	Description	Use Case
Sequential	Traditional linear execution, stages execute in numerical prefix order	Pipeline tasks, strong dependencies, fixed outputs
Autonomous	Intelligent routing, dynamically selects execution path	Interactive tasks, no strong dependencies, dynamic response

Phase 0: Mandatory Prerequisite — Specification study (must complete before continuing)

⚠️ Mandatory Prerequisites:

Do not skip: Before executing any operations, you must completely read the following documents.

Core Specifications (required):

Document	Purpose	Priority
../_shared/SKILL-DESIGN-SPEC.md	General design spec — Defines structure, naming, quality standards for all Skills	P0 - Critical
specs/reference-docs-spec.md	Reference doc generation spec — Ensures generated Skills have appropriate stage-based reference docs	P0 - Critical

Template Files (read before generation):

Document	Purpose
templates/skill-md.md	SKILL.md entry file template
templates/sequential-phase.md	Sequential stage template
templates/autonomous-orchestrator.md	Autonomous orchestrator template
templates/autonomous-action.md	Autonomous action template

Execution Flow:

Phase 0: Specification Study (Mandatory)
   - Read: ../_shared/SKILL-DESIGN-SPEC.md
   - Read: All templates/*.md files
   - Understand: Structure rules, naming conventions, quality standards

Phase 1: Requirement Discovery
   - AskUserQuestion to collect requirements
   - Generate: skill-config.json

Phase 2: Structure Generation
   - Bash: mkdir -p directory structure
   - Write: SKILL.md

Phase 3: Phase/Action Generation (mode dependent)
   - Sequential → Generate phases/*.md
   - Autonomous → Generate orchestrator + actions/*.md

Phase 4: Specifications and Templates
   - Generate: domain specs, templates

Phase 5: Verification and Documentation
   - Verify: Completeness check
   - Generate: README.md, validation-report.json

Output Structure (Sequential):

.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

---

ccw-help

One-Liner: CCW command help system — Command search, recommendations, documentation viewing

Trigger:

/ccw-help
/ccw "task description"          # Auto-select workflow and execute
/ccw-help search <keyword>       # Search commands
/ccw-help next <command>         # Get next step suggestions

Features:

• Command search, recommendations, documentation viewing
• Automatic workflow orchestration
• Beginner onboarding guidance

Operation Modes:

Mode	Trigger	Description
Command Search	"search commands", "find command"	Query command.json, filter relevant commands
Smart Recommendations	"next steps", "what's next"	Query flow.next_steps
Documentation	"how to use", "how to use"	Read source files, provide context examples
Beginner Onboarding	"beginner", "getting started"	Query essential_commands
CCW Command Orchestration	"ccw ", "auto workflow"	Analyze intent, auto-select workflow
Issue Reporting	"ccw-issue", "report bug"	Collect context, generate issue template

Supported Workflows:

• Level 1 (Lite-Lite-Lite): Super simple quick tasks
• Level 2 (Rapid/Hotfix): Bug fixes, simple features, documentation
• Level 2.5 (Rapid-to-Issue): Bridge from rapid planning to Issue workflow
• Level 3 (Coupled): Complex features (plan, execute, review, test)
• Level 3 Variants: TDD, Test-fix, Review, UI design workflows
• Level 4 (Full): Exploratory tasks (brainstorm)
• With-File Workflows: Documented exploration (multi-CLI collaboration)
• Issue Workflow: Batch Issue discovery, planning, queuing, execution

Slash Commands:

/ccw "task description"          # Auto-select workflow and execute
/ccw-help                        # Help entry
/ccw-help search <keyword>       # Search commands
/ccw-help next <command>         # Next step suggestions
/ccw-issue                       # Issue report

CCW Command Examples:

/ccw "Add user authentication"     # → auto-select level 2-3
/ccw "Fix memory leak"             # → auto-select bugfix
/ccw "Implement with TDD"          # → detect TDD workflow
/ccw "brainstorm: User notification system"  # → detect brainstorm

Statistics:

• Commands: 50+
• Agents: 16
• Workflows: 6 main levels + 3 with-file variants
• Essential: 10 core commands

---

skill-tuning

One-Liner: Skill tuning diagnosis — Automated diagnosis and optimization recommendations

Trigger:

/skill-tuning <skill-name>

Features:

• Diagnose Skill issues
• Provide optimization recommendations
• Apply optimizations
• Verify improvements

Diagnosis Flow:

Analyze Skill → Identify issues → Generate recommendations → Apply optimizations → Verify effects

---

command-generator

One-Liner: Command generator — Generate Claude commands

Trigger:

/command-generator

Features:

• Generate commands based on requirements
• Follow command specifications
• Generate command documentation

---

issue-manage

One-Liner: Issue management — Issue creation, updates, status management

Trigger:

/issue-manage
/issue:new

Features:

• Issue creation
• Issue status management
• Issue associations and dependencies

Related Commands

• Claude Commands - CLI
• CCW CLI Tools

Best Practices

1. Specification generation: Use spec-generator to generate complete specification package, then handoff to execution workflows
2. Brainstorming: Use brainstorm for multi-role analysis to get comprehensive perspectives
3. Skill creation: Use skill-generator to create specification-compliant Skills
4. Command help: Use ccw-help to find commands and workflows
5. Continuous tuning: Use skill-tuning to regularly optimize Skill performance

Usage Examples

# Generate product specification
/spec-generator "Build real-time collaboration platform"

# Brainstorm
/brainstorm "Design payment system" --count 3
/brainstorm system-architect --session WFS-xxx

# Create new Skill
/skill-generator

# Get help
/ccw "Add JWT authentication"
/ccw-help search "review"

# Manage Issues
/issue-manage