Breaking Down Work

Transform epics into complete feature/task hierarchies ready for sprint execution.

Usage

/breaking-down-work <item-id> [options]

Arguments

Item ID (required):

Epic or large work item to break down (e.g., CCC-123, PROJ-100)

Options:

--skip-prep: Skip structure preparation phase
--dry-run: Preview breakdown without creating items
--max-features N: Limit features created (default: no limit)
--analyze-codebase: Enable parallel codebase analysis (default: on)
--no-analysis: Skip codebase analysis for faster execution

Examples

# Full breakdown with preparation
/breaking-down-work CCC-123

# Skip preparation (epic already structured)
/breaking-down-work CCC-123 --skip-prep

# Preview without creating items
/breaking-down-work CCC-123 --dry-run

# Quick breakdown without codebase analysis
/breaking-down-work CCC-123 --no-analysis

Workflow

Phase 0: Structure Preparation

Skip if --skip-prep specified

Gather Context
- Fetch epic via pm-context get_item(id)
- Get team/project context
- Analyze current epic structure
- Find existing child items
Completeness Analysis
- Parse epic objectives from description
- Identify technical components mentioned
- Extract success criteria
- Map existing feature coverage
Gap Identification
- Find objectives without matching features
- Identify orphan items that belong to this epic
- Check for metadata inconsistencies
Apply Fixes
- Create missing features for coverage gaps
- Link high-confidence orphans to epic
- Fix metadata inconsistencies (priority, labels)

Phase 1: Readiness Assessment

Validate epic is ready for breakdown:

Readiness Checklist:

[ ] Has problem statement
[ ] Has user stories or requirements
[ ] Has acceptance criteria
[ ] Has success metrics
[ ] Has technical requirements
[ ] Priority is set
[ ] Scope is clear (no vague terms)

If Not Ready: Report missing elements with specific guidance and exit.

Phase 2: Feature Pre-Planning

Identify Work Areas
- Extract from epic description
- Derive from user stories
- Identify technical components
Launch Parallel Analysis (unless --no-analysis)

For each work area, launch analysis agent:
```
Read prompts/code-analysis.md for agent prompt template
```
CRITICAL: Launch ALL agents in a single response for parallelization
Collect Results
- Technical context per area
- Implementation requirements
- Suggested features
- Complexity estimates
- Identified risks

Phase 3: Feature Planning

Apply Sizing Guidelines

| Size | Duration | Criteria | Tasks | |------|----------|----------|-------| | Small | 1-2 days | 3-5 AC, single component | 1-3 | | Medium | 2-3 days | 5-8 AC, some integration | 3-5 | | Large | 3-5 days | 8-12 AC, subsystem | 5-8 |

If larger than Large → split into multiple features
Generate Feature List
- Right-size each suggested feature
- Assign to phase (Foundation/Features/Integration)
- Identify parallelization opportunities
- Create feature specifications using templates/feature.md
Generate Tasks per Feature
- Max 5 tasks per feature
- Each task < 1 day
- Include testing task
- Use templates/task.md

Phase 4: Create Items

Create Features

For each feature:
  pm-context.create_item({
    type: "feature",
    title: feature.title,
    description: formatted_feature,
    parent: epic_id
  })

Create Tasks

For each task:
  pm-context.create_item({
    type: "task",
    title: task.title,
    description: formatted_task,
    parent: feature_id
  })

Phase 5: Dependency Analysis

Identify Dependencies
- Foundation phase blocks Features phase
- Integration phase depends on Features
- Technical dependencies between features
Set Blocking Relationships
- Update items with blockers (where PM tool supports)
- Add dependency notes to descriptions
Validate No Cycles
- Check for circular dependencies
- Report and fix if found

Phase 6: Generate Report

Output comprehensive breakdown summary:

## Epic Breakdown Complete: {title}

### Preparation Summary
- Structure Fixes: {count}
- Features Created: {count}
- Orphans Matched: {count}

### Breakdown Summary
- Total Features: {count}
- Total Tasks: {count}
- Total Items: {count}

### Distribution by Phase
- Foundation: {count} ({percent}%)
- Features: {count} ({percent}%)
- Integration: {count} ({percent}%)

### Parallelization Analysis
- Max Parallel: {count} features
- Independent Streams: {count}
- Critical Path: {count} features

### Sprint Recommendations
Based on breakdown, suggest sprint allocation.

### Next Steps
1. Review created features
2. Adjust dependencies if needed
3. Run /managing-sprints plan <epic-id>

Validation Checks

Before completing:

[ ] No feature larger than 8 tasks
[ ] No task without parent feature
[ ] All features have acceptance criteria
[ ] Dependencies form valid DAG (no cycles)
[ ] Features phase > 60% parallelizable

Error Handling

| Error | Recovery | |-------|----------| | Epic not ready | Report missing elements, exit | | Analysis agent fails | Retry up to 2 times | | Feature too large | Auto-split | | Circular dependency | Detect and report | | PM tool rate limit | Batch with delays |

Output Example

🔧 Starting structure preparation...
📊 Found 4 existing features, 2 orphan tasks

✅ Preparation Complete
- Created 1 feature for missing coverage
- Matched 1 orphan to epic

🔍 Analyzing Epic: User Authentication System
✅ Epic ready for breakdown

📊 Launching 5 Parallel Analysis Agents
- Agent-1: Database schema
- Agent-2: JWT implementation
- Agent-3: OAuth providers
- Agent-4: Frontend components
- Agent-5: API endpoints

⏳ Collecting results...
✅ All analyses complete

📝 Planning Features and Tasks
- 12 features across 3 phases
- 43 tasks total
- Max parallelization: 8 features

🔨 Creating Items
- Creating 12 features... ✅
- Creating 43 tasks... ✅
- Setting dependencies... ✅

📊 Epic Breakdown Complete!
- 75% can run in parallel
- 3 suggested sprints

Ready for sprint planning!