Skip to main content
command CX Codex

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

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/commands/spawn.md
Open on GitHub

What 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.md

Call it with /spawn. For all projects use ~/.claude/commands/

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

Similar slash commands

All slash commands for Agent setup: memory, context, orchestration →

From the same set56

The whole set →
reflect reflect evaluates task adherence and session progress using Serena MCP analysis tools. Useful for quality checks before marking tasks as complete. CX Codex +1 ★ 23,950repo stars explain A command to explain code, system architecture, and concepts at the right level of depth. Helps you understand unfamiliar code or teach concepts to others. CX Codex +1 ★ 23,950repo stars index index scans project architecture to build structured knowledge bases, API references, or README files with cross-references. CX Codex +1 ★ 23,950repo stars troubleshoot troubleshoot diagnoses runtime errors, build failures, performance bottlenecks, and deployment bugs. It inspects the system state and never modifies files unless passed --fix. CX Codex +1 ★ 23,950repo stars cleanup The cleanup command for Claude Code finds dead code, removes unused imports, and tidies project structure without breaking public APIs. CX Codex +1 ★ 23,950repo stars deep-research-agent The deep-research-agent subagent investigates complex questions, checks sources, and turns findings into a cited report. Use it for current topics or when information needs careful synthesis. CX Codex ★ 23,950repo stars improve improve removes technical debt, tunes execution speed, and patches vulnerabilities in your project. Useful for component refactoring and enforcing code standards. CX Codex +1 ★ 23,950repo stars estimate This command estimates development time, effort, or complexity and returns a breakdown with risks. Use it to scope work before implementation begins. CX Codex +1 ★ 23,950repo stars

Project sponsors

Companies that keep this analytics open