spawn — Claude Code command: task orchestration and breakdown
spawn — a command that breaks down large multi-domain operations into hierarchical task plans with dependencies and delegation. Analyzes scope, decomposes work, and assigns executors—it plans rather than implements.
MIT ★ 23,950 updated 2026-09-27
.claude/commands/spawn.mdWhat spawn does
spawn takes a complex operation and parses it into epics, stories, and subtasks. It maps dependencies, selects a coordination strategy (sequential, parallel, or adaptive), and outputs a task hierarchy with assignments to sub-commands (/sc:implement, /sc:design, /sc:test) for each block. No MCP-server dependencies: orchestration runs natively.
The output is a task breakdown document—actual code and system changes flow through delegated commands. Handy for monolith-to-microservices migration, large refactors, multi-layer infrastructure setups, or any operation that spans frontend, backend, DevOps, and QA.
What it helps with
- break a large project into manageable blocks with clear dependencies
- plan a migration, refactor, or infrastructure overhaul
- coordinate cross-domain work: backend API, frontend UI, CI/CD, security
- decide what runs in parallel versus sequential order
- delegate subtasks to specialized commands
Example prompts for the agent
- Plan an authentication system rollout: database schema, API endpoints, UI, integration tests
- /sc:spawn "migrate legacy monolith to microservices" --strategy adaptive --depth deep
- Break down CI/CD pipeline setup with security scanning and validation gates
How to install spawn
Manually: put the files in place
.claude/commands/spawn.mdCall it with /spawn. For all projects use ~/.claude/commands/
Manually: put the files in place
~/.codex/prompts/spawn.mdCall it with /prompts:spawn. Codex marks this format deprecated in favour of skills
Manually: put the files in place
.github/prompts/spawn.prompt.mdManually: put the files in place
.gemini/commands/spawn.tomlGemini stores commands as TOML: the prompt text goes into the prompt field
Questions about spawn
How do I install spawn in Claude Code?
Copy .claude/commands/spawn.md into your project. spawn is part of the SuperClaude Framework and runs via /sc:spawn in Claude Code.
What does spawn do?
It decomposes a complex task into a hierarchy of epics, stories, and subtasks. It builds a plan with dependency analysis and picks a coordination strategy (sequential, parallel, or adaptive). It plans and delegates—it doesn't execute work itself.
How is spawn different from other commands?
Most commands solve a specific problem. spawn is a meta-command: it steps back, looks at the whole operation, breaks it into parts, analyzes how they relate, and decides which command should handle each piece.
Source text
spawn.md · MIT
--- name: spawn description: "Meta-system task orchestration with intelligent breakdown and delegation" category: special complexity: high mcp-servers: [] personas: [] --- # /sc:spawn - Meta-System Task Orchestration ## Triggers - Complex multi-domain operations requiring intelligent task breakdown - Large-scale system operations spanning multiple technical areas - Operations requiring parallel coordination and dependency management - Meta-level orchestration beyond standard command capabilities ## Usage ``` /sc:spawn [complex-task] [--strategy sequential|parallel|adaptive] [--depth normal|deep] ``` ## Behavioral Flow 1. **Analyze**: Parse complex operation requirements and assess scope across domains 2. **Decompose**: Break down operation into coordinated subtask hierarchies 3. **Orchestrate**: Execute tasks using optimal coordination strategy (parallel/sequential) 4. **Monitor**: Track progress across task hierarchies with dependency management 5. **Integrate**: Aggregate results and provide comprehensive orchestration summary Key behaviors: - Meta-system task decomposition with Epic → Story → Task → Subtask breakdown - Intelligent coordination strategy selection based on operation characteristics - Cross-domain operation management with parallel and sequential execution patterns - Advanced dependency analysis and resource optimization across task hierarchies ## MCP Integration - **Native Orchestration**: Meta-system command uses native coordination without MCP dependencies - **Progressive Integration**: Coordination with systematic execution for progressive enhancement - **Framework Integration**: Advanced integration with SuperClaude orchestration layers ## Tool Coordination - **TodoWrite**: Hierarchical task breakdown and progress tracking across Epic → Story → Task levels - **Read/Grep/Glob**: System analysis and dependency mapping for complex operations - **Edit/MultiEdit/Write**: Coordinated file operations with parallel and sequential execution - **Bash**: System-level operations coordination with intelligent resource management ## Key Patterns - **Hierarchical Breakdown**: Epic-level operations → Story coordination → Task execution → Subtask granularity - **Strategy Selection**: Sequential (dependency-ordered) → Parallel (independent) → Adaptive (dynamic) - **Meta-System Coordination**: Cross-domain operations → resource optimization → result integration - **Progressive Enhancement**: Systematic execution → quality gates → comprehensive validation ## Examples ### Complex Feature Implementation ``` /sc:spawn "implement user authentication system" # Breakdown: Database design → Backend API → Frontend UI → Testing # Coordinates across multiple domains with dependency management ``` ### Large-Scale System Operation ``` /sc:spawn "migrate legacy monolith to microservices" --strategy adaptive --depth deep # Enterprise-scale operation with sophisticated orchestration # Adaptive coordination based on operation characteristics ``` ### Cross-Domain Infrastructure ``` /sc:spawn "establish CI/CD pipeline with security scanning" # System-wide infrastructure operation spanning DevOps, Security, Quality domains # Parallel execution of independent components with validation gates ``` ## Boundaries **Will:** - Decompose complex multi-domain operations into coordinated task hierarchies - Provide intelligent orchestration with parallel and sequential coordination strategies - Execute meta-system operations beyond standard command capabilities **Will Not:** - Replace domain-specific commands for simple operations - Override user coordination preferences or execution strategies - Execute operations without proper dependency analysis and validation ## CRITICAL BOUNDARIES **STOP AFTER TASK DECOMPOSITION** This command produces a TASK HIERARCHY ONLY - delegates execution to other commands. **Explicitly Will NOT**: - Execute implementation tasks directly - Write or modify code - Create system changes - Replace domain-specific commands **Output**: Task breakdown document with: - Epic decomposition - Task hierarchy with dependencies - Delegation assignments (which `/sc:*` command handles each task) - Coordination strategy **Next Step**: Execute individual tasks using delegated commands (`/sc:implement`, `/sc:design`, `/sc:test`, etc.)
© SuperClaude-Org · MIT · SuperClaude-Org/SuperClaude_Framework