planning-strategy-guide

What this skill does

# Planning Strategy Guide

Expert planning assistant that helps you decompose complex tasks, assess complexity, identify dependencies, and create comprehensive implementation plans.

## When to Use

This skill auto-activates when:

- **Epic breakdown**: "Break down this epic into tasks"
- **Feature decomposition**: "How do I plan this complex feature?"
- **Scope estimation**: "What's the scope of this work?"
- **Complexity assessment**: "How complex is this task?"
- **Dependency analysis**: "What are the dependencies?"
- **Risk identification**: "What risks should I consider?"
- **Planning strategy**: "Help me structure this project"
- **Effort estimation**: "I need to estimate effort for this"

## Planning Phases

This skill guides you through **6 planning phases** for comprehensive task decomposition:

### Phase 1: Complexity Assessment

**Purpose**: Evaluate task complexity to determine planning approach

**Complexity Rubric**:
- **Simple** (1-2 files, clear scope)
  - Single component modification
  - Well-defined requirements
  - No external dependencies
  - Estimated: 1-4 hours

- **Medium** (3-8 files, some unknowns)
  - Multiple component changes
  - Some research needed
  - Few external dependencies
  - Estimated: 1-3 days

- **Complex** (9+ files, research needed, multiple systems)
  - Cross-system changes
  - Significant research required
  - Many dependencies and integrations
  - Estimated: 4+ days

**Questions to ask**:
1. How many files will be modified?
2. Are requirements fully understood?
3. Are there external system integrations?
4. How much research is needed?

### Phase 2: Scope Definition

**Purpose**: Clearly define boundaries and deliverables

**Key elements**:
- **In scope**: What will be implemented
- **Out of scope**: What will NOT be implemented
- **Acceptance criteria**: How to verify completion
- **Success metrics**: How to measure success

**Questions to ask**:
1. What is the minimal viable implementation?
2. What features can be deferred?
3. What defines "done"?
4. What are the acceptance criteria?

### Phase 3: Dependency Analysis

**Purpose**: Identify dependencies and proper execution order

**Dependency types**:
- **Hard dependencies**: Must complete A before B
- **Soft dependencies**: Prefer A before B, but not required
- **Parallel work**: Can execute simultaneously
- **Blocking dependencies**: External dependencies not in your control

**Questions to ask**:
1. What must be completed first?
2. What can run in parallel?
3. Are there external blockers?
4. What's the critical path?

### Phase 4: Risk Identification

**Purpose**: Identify potential challenges and mitigation strategies

**Common risk categories**:
- **Technical risks**: Unknown technologies, complex algorithms
- **Integration risks**: Third-party APIs, external systems
- **Performance risks**: Scalability, response time
- **Security risks**: Authentication, data protection
- **Timeline risks**: Underestimated effort, scope creep

**For each risk**:
- **Likelihood**: Low/Medium/High
- **Impact**: Low/Medium/High
- **Mitigation**: How to reduce or eliminate
- **Contingency**: Plan B if it occurs

### Phase 5: Task Breakdown

**Purpose**: Decompose feature into actionable subtasks

**Breakdown principles**:
- **Atomic**: Each task is a single, focused unit
- **Testable**: Each task has clear verification
- **Estimable**: Can reasonably estimate effort
- **Independent**: Minimal coupling between tasks
- **Ordered**: Logical execution sequence

**Example breakdown**:
```
Epic: User Authentication
├── Feature: Login Flow
│   ├── Task: Create login API endpoint
│   ├── Task: Add JWT token generation
│   ├── Task: Implement password validation
│   └── Task: Add login UI form
├── Feature: Session Management
│   ├── Task: Add token refresh logic
│   └── Task: Handle session expiration
└── Feature: Security
    ├── Task: Add rate limiting
    └── Task: Implement 2FA support
```

### Phase 6: Effort Estimation

**Purpose**: Estimate time and resources needed

**Estimation approaches**:
1. **T-shirt sizing**: XS/S/M/L/XL (relative sizing)
2. **Story points**: Fibonacci sequence (1, 2, 3, 5, 8, 13)
3. **Time-based**: Hours or days (absolute sizing)

**Factors to consider**:
- **Complexity**: How technically challenging
- **Uncertainty**: How much is unknown
- **Dependencies**: How many blockers
- **Experience**: Team familiarity with domain

**Buffer rule**: Add 20-30% buffer for unknowns

## Integration with CCPM

### Commands that Activate This Skill

This skill enhances the following CCPM commands:

1. **`/ccpm:plan`** - Smart planning with phase detection
   - Detects complexity automatically
   - Suggests appropriate planning depth
   - Provides interactive guidance

2. **`/ccpm:plan`** - Extended planning with research
   - Activates all 6 planning phases
   - Integrates with docs-seeker for research
   - Creates comprehensive Linear issue

3. **`/ccpm:plan`** - Plan modifications
   - Analyzes impact of changes
   - Re-evaluates complexity and scope
   - Provides side-by-side comparison

4. **`/ccpm:plan`** - Spec-first development
   - Helps structure spec sections
   - Identifies missing requirements
   - Ensures comprehensive coverage

5. **`/ccpm:plan`** - Epic/feature decomposition
   - Uses task breakdown phase
   - Analyzes dependencies
   - Creates properly ordered subtasks

### Skills that Work Alongside

This skill integrates with:

1. **sequential-thinking** - For complex task decomposition
   - Uses iterative reasoning
   - Explores alternative approaches
   - Shows thought process

2. **docs-seeker** - For research during planning
   - Finds relevant documentation
   - Provides code examples
   - Flags important caveats

3. **pm-workflow-guide** - For command recommendations
   - Suggests next actions
   - Shows workflow state
   - Prevents common mistakes

4. **linear-subagent-guide** - For updating Linear
   - Optimizes Linear operations
   - Uses caching effectively
   - Structures updates properly

5. **external-system-safety** - For Jira/Confluence reads
   - Confirms external writes
   - Shows exact content
   - Maintains audit trail

6. **workflow-state-tracking** - For state transitions
   - Visualizes workflow state
   - Validates transitions
   - Suggests next phase

## Instructions

### Step 1: Detect Planning Need

When user mentions planning-related keywords, activate and assess their need:

```
User: "I need to plan this complex payment integration"
       ↓
[planning-strategy-guide activates]
       ↓
Assess: Type of planning needed (epic breakdown? complexity assessment?)
```

### Step 2: Ask Clarifying Questions

Use AskUserQuestion to gather context:

```javascript
AskUserQuestion({
  questions: [{
    question: "What type of planning assistance do you need?",
    header: "Planning Type",
    multiSelect: false,
    options: [
      {
        label: "Break down large feature",
        description: "Decompose epic/feature into tasks"
      },
      {
        label: "Assess complexity",
        description: "Evaluate technical complexity and effort"
      },
      {
        label: "Identify dependencies",
        description: "Map task dependencies and order"
      },
      {
        label: "Analyze risks",
        description: "Identify potential challenges"
      }
    ]
  }]
});
```

### Step 3: Run Appropriate Planning Phases

Based on user's selection, run relevant phases:

**For epic breakdown**:
1. Run Phase 1 (Complexity Assessment)
2. Run Phase 5 (Task Breakdown)
3. Run Phase 3 (Dependency Analysis)
4. Run Phase 6 (Effort Estimation)

**For complexity assessment**:
1. Run Phase 1 (Complexity Assessment)
2. Run Phase 4 (Risk Identification)
3. Run Phase 6 (Effort Estimation)

**For scope definition**:
1. Run Phase 2 (Scope Definition)
2. Run Phase 1 (Complexity Assessment)
3. Run Phase 6 (Effort Estimation)

### Step 4: Integrate with Other Skills

Based on complexity, invoke complementary skills:

**Complex tasks** → I