decomposition-planning-roadmap

What this skill does

# Decomposition Planning and Roadmap

This skill creates structured decomposition plans and roadmaps to guide the migration from monolithic to distributed architectures, prioritizing work and tracking progress through decomposition patterns.

## How to Use

### Quick Start

Request creation of a decomposition plan:

- **"Create a decomposition roadmap for this codebase"**
- **"Plan the decomposition migration strategy"**
- **"Prioritize decomposition work based on component analysis"**
- **"Create a step-by-step decomposition plan"**

### Usage Examples

**Example 1: Complete Roadmap**

```
User: "Create a decomposition roadmap for this codebase"

The skill will:
1. Analyze current codebase state
2. Identify decomposition patterns to apply
3. Prioritize work based on risk and value
4. Create phased roadmap
5. Generate architecture stories
6. Estimate effort and dependencies
```

**Example 2: Prioritized Plan**

```
User: "Prioritize decomposition work based on component analysis"

The skill will:
1. Review component inventory and dependencies
2. Assess risk and value for each pattern
3. Prioritize patterns by impact
4. Create prioritized work plan
```

**Example 3: Phase Planning**

```
User: "Create a phased decomposition plan"

The skill will:
1. Group decomposition patterns into phases
2. Identify dependencies between phases
3. Create phase timeline
4. Define phase success criteria
```

### Step-by-Step Process

1. **Assess Current State**: Analyze codebase and identify what's been done
2. **Identify Patterns**: Determine which decomposition patterns to apply
3. **Prioritize Work**: Rank patterns by risk, value, and dependencies
4. **Create Roadmap**: Build phased plan with milestones
5. **Generate Stories**: Create architecture stories for tracking
6. **Track Progress**: Monitor progress through decomposition phases

## When to Use

Apply this skill when:

- Starting a decomposition effort
- Planning migration from monolith to distributed architecture
- Prioritizing decomposition work
- Creating architecture stories for decomposition
- Tracking progress through decomposition patterns
- Need structured approach to decomposition
- Want to estimate effort and dependencies

## Core Concepts

### Decomposition Pattern Sequence

The six component-based decomposition patterns should be applied in sequence:

1. **Identify and Size Components** - Understand what you have
2. **Gather Common Domain Components** - Find duplicates
3. **Flatten Components** - Remove orphaned classes
4. **Determine Component Dependencies** - Assess coupling
5. **Create Component Domains** - Group into domains
6. **Create Domain Services** - Extract to services

### Phased Approach

Decomposition typically follows phases:

**Phase 1: Analysis & Preparation** (Patterns 1-4)

- Component identification and sizing
- Common component detection
- Component flattening
- Dependency analysis

**Phase 2: Domain Organization** (Pattern 5)

- Domain identification
- Component grouping
- Namespace refactoring

**Phase 3: Service Extraction** (Pattern 6)

- Domain service creation
- Service extraction
- API boundary definition

### Prioritization Factors

When prioritizing decomposition work, consider:

- **Risk**: Low risk = easier to extract, fewer dependencies
- **Value**: High value = business-critical, high impact
- **Dependencies**: Can this be done independently?
- **Complexity**: Simple = fewer components, clear boundaries
- **Coupling**: Low coupling = easier to extract

## Analysis Process

### Phase 1: Assess Current State

Analyze what's already been done:

1. **Check Component Inventory**
   - Have components been identified and sized?
   - Is there a component inventory document?
   - Are oversized components identified?

2. **Check Common Component Analysis**
   - Have common domain components been identified?
   - Are consolidation opportunities documented?
   - Has coupling impact been analyzed?

3. **Check Component Structure**
   - Have components been flattened?
   - Are there orphaned classes?
   - Is component structure clean?

4. **Check Dependency Analysis**
   - Have component dependencies been mapped?
   - Is coupling analysis complete?
   - Is feasibility assessed?

5. **Check Domain Identification**
   - Have domains been identified?
   - Are components grouped into domains?
   - Are namespaces aligned with domains?

6. **Check Service Extraction**
   - Have any services been extracted?
   - Are domain services created?
   - Is service-based architecture in place?

**Output**: Current state assessment showing what's done and what's remaining

### Phase 2: Identify Patterns to Apply

Determine which decomposition patterns need to be applied:

1. **Review Pattern Prerequisites**
   - Pattern 1: Always needed (foundation)
   - Pattern 2: Needed if common components exist
   - Pattern 3: Needed if components have hierarchy
   - Pattern 4: Always needed (feasibility check)
   - Pattern 5: Needed before service extraction
   - Pattern 6: Final step (service extraction)

2. **Check Pattern Completion**
   - Which patterns are complete?
   - Which patterns are in progress?
   - Which patterns haven't started?

3. **Identify Missing Patterns**
   - What patterns still need to be applied?
   - What's blocking pattern application?
   - What dependencies exist?

**Output**: List of patterns to apply with status

### Phase 3: Prioritize Work

Prioritize decomposition patterns and work items:

1. **Assess Risk**
   - Low Risk: Infrastructure components, standalone functionality
   - Medium Risk: Domain components with some dependencies
   - High Risk: Core business logic, high coupling

2. **Assess Value**
   - High Value: Business-critical, high impact, frequent changes
   - Medium Value: Important but not critical
   - Low Value: Nice to have, low impact

3. **Assess Dependencies**
   - Independent: Can be done without other work
   - Dependent: Requires other patterns/work first
   - Blocking: Blocks other work from proceeding

4. **Calculate Priority Score**

   ```
   Priority = (Value × 3) - (Risk × 2) - (Dependencies × 1)

   Higher score = Higher priority
   ```

**Output**: Prioritized list of patterns and work items

### Phase 4: Create Phased Roadmap

Build a phased roadmap with milestones:

1. **Define Phases**
   - Phase 1: Analysis & Preparation
   - Phase 2: Domain Organization
   - Phase 3: Service Extraction
   - Phase 4: Optimization & Refinement

2. **Assign Patterns to Phases**
   - Which patterns belong in which phase?
   - What's the sequence within each phase?
   - What are the phase dependencies?

3. **Set Milestones**
   - What marks completion of each phase?
   - What are the success criteria?
   - What deliverables are expected?

4. **Estimate Timeline**
   - How long will each phase take?
   - What are the dependencies?
   - What's the critical path?

**Output**: Phased roadmap with timeline and milestones

### Phase 5: Generate Architecture Stories

Create architecture stories for tracking work:

1. **Create Story Template**

   ```
   As an architect, I need to [apply pattern/refactor component]
   to support [architectural characteristic/business need]
   so that [benefit/outcome]
   ```

2. **Break Down Work**
   - One story per pattern application
   - One story per major refactoring
   - One story per domain grouping

3. **Add Acceptance Criteria**
   - What defines "done"?
   - What metrics validate success?
   - What tests verify completion?

4. **Estimate Effort**
   - Story points or time estimates
   - Complexity assessment
   - Risk factors

**Output**: List of architecture stories with estimates

### Phase 6: Track Progress

Monitor progress through decomposition:

1. **Track Pattern Completion**
   - Which patterns are complete?
   - Which are in progress?
   - Which are blocked?

2. **Track Story Completion**
   - Stories completed
   - Stories in progress
   - Stories not started

3. **Track Metrics**
   - Components identified