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:

•How many files will be modified?
•Are requirements fully understood?
•Are there external system integrations?
•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:

•What is the minimal viable implementation?
•What features can be deferred?
•What defines "done"?
•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:

•What must be completed first?
•What can run in parallel?
•Are there external blockers?
•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:

code

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:

•T-shirt sizing: XS/S/M/L/XL (relative sizing)
•Story points: Fibonacci sequence (1, 2, 3, 5, 8, 13)
•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:

•
/ccpm:plan - Smart planning with phase detection
- •Detects complexity automatically
- •Suggests appropriate planning depth
- •Provides interactive guidance
•
/ccpm:plan - Extended planning with research
- •Activates all 6 planning phases
- •Integrates with docs-seeker for research
- •Creates comprehensive Linear issue
•
/ccpm:plan - Plan modifications
- •Analyzes impact of changes
- •Re-evaluates complexity and scope
- •Provides side-by-side comparison
•
/ccpm:plan - Spec-first development
- •Helps structure spec sections
- •Identifies missing requirements
- •Ensures comprehensive coverage
•
/ccpm:plan - Epic/feature decomposition
- •Uses task breakdown phase
- •Analyzes dependencies
- •Creates properly ordered subtasks

Skills that Work Alongside

This skill integrates with:

•
sequential-thinking - For complex task decomposition
- •Uses iterative reasoning
- •Explores alternative approaches
- •Shows thought process
•
docs-seeker - For research during planning
- •Finds relevant documentation
- •Provides code examples
- •Flags important caveats
•
pm-workflow-guide - For command recommendations
- •Suggests next actions
- •Shows workflow state
- •Prevents common mistakes
•
linear-subagent-guide - For updating Linear
- •Optimizes Linear operations
- •Uses caching effectively
- •Structures updates properly
•
external-system-safety - For Jira/Confluence reads
- •Confirms external writes
- •Shows exact content
- •Maintains audit trail
•
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:

code

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:

•Run Phase 1 (Complexity Assessment)
•Run Phase 5 (Task Breakdown)
•Run Phase 3 (Dependency Analysis)
•Run Phase 6 (Effort Estimation)

For complexity assessment:

•Run Phase 1 (Complexity Assessment)
•Run Phase 4 (Risk Identification)
•Run Phase 6 (Effort Estimation)

For scope definition:

•Run Phase 2 (Scope Definition)
•Run Phase 1 (Complexity Assessment)
•Run Phase 6 (Effort Estimation)

Step 4: Integrate with Other Skills

Based on complexity, invoke complementary skills:

Complex tasks → Invoke sequential-thinking:

code

Task(sequential-thinking): "Break down this complex payment integration..."

Research needed → Invoke docs-seeker:

code

Skill: docs-seeker
Query: "Find Stripe API documentation and best practices"

Command suggestion needed → Let pm-workflow-guide activate:

code

[pm-workflow-guide auto-activates]
Suggests: "/ccpm:plan epic 'Payment Integration'"

Step 5: Update Linear with Plan

Use linear-subagent-guide patterns:

yaml

Task(ccpm:linear-operations): `
operation: update_issue_description
params:
  issueId: "${issueId}"
  description: |
    ## Implementation Checklist

    ${generatedChecklist}

    > **Complexity**: ${complexity} | **Estimated**: ${estimate}

    ## Dependencies

    ${dependencyList}

    ## Risks & Mitigation

    ${risksList}

    ---

    ${originalDescription}
context:
  command: "planning-strategy-guide"
  cache: true
`

Step 6: Provide Next Actions

Show user what to do next:

code

✅ Planning Complete!

📊 Results:
  • Complexity: Medium
  • Tasks: 8 subtasks identified
  • Dependencies: 3 hard dependencies
  • Risks: 2 medium risks identified
  • Estimate: 2-3 days

💡 Next Steps:
  1. Review the plan in Linear
  2. Start implementation: /ccpm:work ${issueId}
  3. Create spec if complex: /ccpm:plan

Examples

Example 1: Complex Feature Breakdown

code

User: "Help me plan this payment gateway integration"

Claude: [planning-strategy-guide activates]

I'll help you plan the payment gateway integration. Let me start by assessing the complexity.

[Asks clarifying questions via AskUserQuestion]

Based on your answers, this is a **Complex** task (9+ files, external API integration).

Let me run the 6 planning phases:

**Phase 1: Complexity Assessment**
- External API integration (Stripe)
- Security considerations (PCI compliance)
- Multiple payment methods
- Webhook handling
→ Complexity: High

**Phase 2: Scope Definition**
In scope:
  • Credit card payments
  • Stripe integration
  • Basic webhook handling
Out of scope:
  • PayPal integration (defer to Phase 2)
  • Subscription management (defer)

**Phase 3: Dependency Analysis**
Hard dependencies:
  1. Stripe account setup (external)
  2. Security review approval (external)
  3. Database schema for payments

Parallel work:
  • Frontend payment form
  • Backend API endpoints
  • Webhook handlers

**Phase 4: Risk Identification**
1. **PCI Compliance** (High impact, Medium likelihood)
   - Mitigation: Use Stripe.js (no card data touches server)

2. **Webhook reliability** (Medium impact, Medium likelihood)
   - Mitigation: Implement idempotency keys

3. **API rate limits** (Low impact, Low likelihood)
   - Mitigation: Add exponential backoff

**Phase 5: Task Breakdown**
Epic: Payment Gateway Integration
├── Set up Stripe account and API keys
├── Implement payment API endpoints
│   ├── Create payment intent endpoint
│   ├── Confirm payment endpoint
│   └── Refund payment endpoint
├── Build frontend payment form
│   ├── Integrate Stripe.js
│   ├── Add card input component
│   └── Handle payment errors
├── Add webhook handlers
│   ├── payment_intent.succeeded
│   ├── payment_intent.failed
│   └── refund.updated
├── Add database schema
│   ├── payments table
│   └── payment_events table
├── Write tests
│   ├── API endpoint tests
│   ├── Webhook handler tests
│   └── Integration tests
└── Security review

**Phase 6: Effort Estimation**
- Total: 12 tasks
- Estimate: 5-7 days (with 20% buffer)
- Story points: 21 points

✅ Planning complete! Would you like me to:
1. Create Linear issue with this plan: /ccpm:plan
2. Create spec document: /ccpm:plan
3. Start implementation: /ccpm:work

Example 2: Simple Task Complexity Assessment

code

User: "How complex is adding a logout button?"

Claude: [planning-strategy-guide activates - lightweight mode]

Let me assess the complexity:

**Phase 1: Complexity Assessment**
- Files to modify: 2 (logout button component, API endpoint)
- Clear requirements: Yes
- External dependencies: None
- Research needed: Minimal

→ **Complexity: Simple** (1-2 hours)

**Quick Plan**:
1. Add logout button to UI (30 min)
2. Call logout API endpoint (15 min)
3. Clear session/cookies (15 min)
4. Test (30 min)

**Estimate**: 1-2 hours

Since this is simple, you can start immediately:
/ccpm:plan "Add logout button"

Example 3: Dependency Analysis for Parallel Work

code

User: "What order should I implement these features?"

Claude: [planning-strategy-guide activates - Phase 3]

Let me analyze the dependencies:

**Phase 3: Dependency Analysis**

Your features:
1. User authentication
2. Profile page
3. Settings page
4. Admin dashboard

Dependency graph:

┌─────────────────┐ │ Authentication │ (Must be first) └────────┬────────┘ │ ┌────┴────┬────────────┐ │ │ │ ┌───▼──┐ ┌───▼──┐ ┌─────▼──────┐ │Profile│ │Settings│ │Admin Dash│ └──────┘ └────────┘ └────────────┘ (parallel work possible)

code


**Execution order**:
1. **First**: Implement authentication (blocker for all others)
2. **Then in parallel**:
   - Profile page (Team A)
   - Settings page (Team B)
   - Admin dashboard (Team C)

**Critical path**: Authentication → Any feature (all equal)

**Recommendation**:
- Start with: /ccpm:plan "User authentication"
- After auth done, all 3 can proceed in parallel

Example 4: Risk Identification

code

User: "What could go wrong with this API migration?"

Claude: [planning-strategy-guide activates - Phase 4]

Let me identify risks for your API migration:

**Phase 4: Risk Identification**

**1. Breaking Changes** (High impact, High likelihood)
- Impact: Existing clients break
- Mitigation:
  • Implement API versioning (/v1, /v2)
  • Maintain backward compatibility
  • Provide migration guide
- Contingency: Rollback plan with feature flags

**2. Data Migration Issues** (High impact, Medium likelihood)
- Impact: Data loss or corruption
- Mitigation:
  • Test migration on staging
  • Backup all data before migration
  • Implement migration rollback scripts
- Contingency: Restore from backup

**3. Performance Degradation** (Medium impact, Medium likelihood)
- Impact: Slower API responses
- Mitigation:
  • Load test new API
  • Add caching layer
  • Optimize database queries
- Contingency: Scale infrastructure

**4. Third-party Dependencies** (Low impact, High likelihood)
- Impact: New libraries have bugs
- Mitigation:
  • Use stable versions
  • Test thoroughly
  • Have alternative libraries ready
- Contingency: Fall back to old implementation

**Recommendation**:
Create detailed migration plan with /ccpm:plan
Include rollback procedures and monitoring

Example 5: Effort Estimation with T-Shirt Sizing

code

User: "Estimate effort for these 5 tasks"

Claude: [planning-strategy-guide activates - Phase 6]

**Phase 6: Effort Estimation**

Using T-shirt sizing:

| Task | Size | Effort | Reasoning |
|------|------|--------|-----------|
| Add search bar | **XS** | 1-2h | Simple UI component |
| Implement search API | **S** | 4-6h | Straightforward endpoint |
| Add search filters | **M** | 1-2d | Multiple filter types |
| Full-text search (Elasticsearch) | **L** | 3-5d | New tech, complex setup |
| Search analytics | **M** | 1-2d | Logging + dashboard |

**Total estimate**: 6-10 days (with 20% buffer: 7-12 days)

**Story points breakdown**:
- XS: 1 point → 1 point
- S: 2 points → 2 points
- M: 5 points → 10 points
- L: 8 points → 8 points

**Total**: 21 story points

**Recommendation**:
- Sprint 1: Search bar + API (3 points)
- Sprint 2: Filters + Analytics (10 points)
- Sprint 3: Elasticsearch (8 points)

Would you like me to create tasks in Linear?
/ccpm:plan (will break down into subtasks)

Best Practices

1. Always Start with Complexity Assessment

Don't dive into detailed planning without understanding complexity:

❌ Bad: Immediately create 20 subtasks without assessment ✅ Good: Assess complexity first, then plan depth accordingly

2. Use Progressive Disclosure

Match planning depth to task complexity:

•Simple tasks: Quick assessment (Phase 1 + estimate)
•Medium tasks: Moderate planning (Phases 1, 2, 5, 6)
•Complex tasks: Full planning (All 6 phases)

3. Iterate and Refine

Planning is not one-and-done:

code

Initial plan → Implementation → Learning → Update plan

Use /ccpm:plan to refine plans based on learnings.

4. Document Assumptions

Make assumptions explicit:

code

**Assumptions**:
- Stripe API is stable (confirmed with docs)
- PCI compliance handled by Stripe.js (verified)
- Payment volume < 1000/day (confirmed with product)

5. Consider Multiple Approaches

For complex tasks, evaluate alternatives:

code

**Approach A: Use Stripe**
Pros: Well-documented, PCI compliant
Cons: Monthly fees, vendor lock-in

**Approach B: Use PayPal**
Pros: Wider adoption, familiar to users
Cons: Complex API, less flexible

**Recommendation**: Approach A (Stripe)
Rationale: Better developer experience, clearer documentation

6. Involve Stakeholders Early

For scope definition, ask:

•Product: What's the MVP?
•Design: What's the UX flow?
•Security: What are the requirements?
•DevOps: What's the deployment strategy?

7. Plan for Failure

Always include:

•Error handling tasks
•Monitoring and alerting
•Rollback procedures
•Testing edge cases

8. Use Visual Aids

Dependency graphs, workflow diagrams, and architecture sketches help:

code

[User] → [Frontend] → [API Gateway] → [Payment Service] → [Stripe]
                                            ↓
                                      [Database]
                                            ↓
                                      [Webhook Handler]

Common Patterns

Pattern 1: Epic Breakdown Strategy

When: Large feature spanning multiple sprints

Phases to use: 1, 2, 3, 5, 6

Output: Hierarchical task structure in Linear

Integration:

•Use /ccpm:plan epic first (create spec)
•Then /ccpm:plan (use this skill's Phase 5)

Pattern 2: Complexity-First Planning

When: Unsure how complex a task is

Phases to use: 1, 4, 6

Output: Complexity rating + estimate + risks

Integration:

•Use /ccpm:plan (quick assessment)
•If complex → Invoke sequential-thinking

Pattern 3: Dependency-Driven Planning

When: Multiple interconnected tasks

Phases to use: 3, 5

Output: Dependency graph + execution order

Integration:

•Use /ccpm:work (visualize)
•Create tasks in dependency order

Pattern 4: Risk-Aware Planning

When: High-stakes or unfamiliar territory

Phases to use: 1, 4

Output: Risk register + mitigation strategies

Integration:

•Document in spec: /ccpm:plan <doc-id> security
•Add risks to Linear issue description

Summary

The Planning Strategy Guide is your intelligent planning assistant, providing:

✅ 6 comprehensive planning phases for thorough task analysis ✅ Complexity assessment to match planning depth to task needs ✅ Dependency analysis to identify proper execution order ✅ Risk identification to anticipate and mitigate challenges ✅ Task breakdown to create actionable, testable subtasks ✅ Effort estimation with multiple approaches (t-shirt, story points, time)

Philosophy

Plan smart, not hard: Match planning depth to task complexity. Simple tasks get quick assessments, complex tasks get comprehensive analysis.

Iterate and refine: Planning is continuous. Use learnings from implementation to update plans.

Integrate seamlessly: Works alongside sequential-thinking, docs-seeker, pm-workflow-guide, and other CCPM skills.

Stay practical: Focus on actionable outputs that help you start coding, not just documentation.

Quick Reference

For quick complexity check:

•"How complex is this task?"
•Auto-runs Phase 1 (Complexity Assessment)

For epic breakdown:

•"Break down this feature"
•Auto-runs Phases 1, 3, 5 (Assessment, Dependencies, Breakdown)

For comprehensive planning:

•"Plan this complex feature"
•Auto-runs all 6 phases

Integration commands:

•/ccpm:plan - Smart planning (uses this skill)
•/ccpm:plan - Spec-first (uses Phase 2, 5)
•/ccpm:plan - Refine plan (re-runs relevant phases)

Remember: Good planning makes implementation smooth. Take time to plan well, then execute confidently.