planning-strategy-guide（规划策略指南）

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

1. /ccpm:plan - Extended planning with research

- Activates all 6 planning phases - Integrates with docs-seeker for research - Creates comprehensive Linear issue

1. /ccpm:plan - Plan modifications

- Analyzes impact of changes - Re-evaluates complexity and scope - Provides side-by-side comparison

1. /ccpm:plan - Spec-first development

- Helps structure spec sections - Identifies missing requirements - Ensures comprehensive coverage

1. /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

1. docs-seeker - For research during planning

- Finds relevant documentation - Provides code examples - Flags important caveats

1. pm-workflow-guide - For command recommendations

- Suggests next actions - Shows workflow state - Prevents common mistakes

1. linear-subagent-guide - For updating Linear

- Optimizes Linear operations - Uses caching effectively - Structures updates properly

1. external-system-safety - For Jira/Confluence reads

- Confirms external writes - Shows exact content - Maintains audit trail

1. 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:

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 → Invoke sequential-thinking:

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

Research needed → Invoke docs-seeker:

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

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

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

Step 5: Update Linear with Plan

Use linear-subagent-guide patterns:

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:

✅ 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

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

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

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)

**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

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

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:

Initial plan → Implementation → Learning → Update plan

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

4. Document Assumptions

Make assumptions explicit:

**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:

**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:

[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.