Planning

Comprehensive implementation plans with verification checkpoints and agent assignments.

When to Activate

• •After brainstorming session completes
• •User asks for a "plan" or "breakdown"
• •Feature requires multiple implementation steps
• •User wants to understand scope before starting

Process

1. Analyze Requirements

From brainstorming output or user request:

• •Extract concrete deliverables
• •Identify dependencies between components
• •Estimate complexity of each part
• •Note testing requirements
• •Map to appropriate agents

2. Explore Implementation Context

Before creating tasks:

• •Review existing code architecture
• •Identify files that need modification
• •Check for reusable components
• •Note testing patterns in codebase

3. Create Task Breakdown

Structure tasks with the Task Ledger pattern:

Task Properties:

• •Clear, atomic actions (one logical change per task)
• •Assigned agent type
• •Dependencies on other tasks
• •Verification criteria
• •Estimated complexity (S/M/L)
• •Files to create/modify

4. Apply Risk-Based Ordering

1. •Front-load risky tasks - Uncertain implementations first
2. •Add checkpoint tasks - Integration verification every 3-4 tasks
3. •Mark parallel-capable tasks - Tasks without dependencies
4. •Identify critical path - Longest dependency chain

5. Define Verification Gates

Each task includes:

• •Commands to run after completion
• •Expected outcomes
• •Rollback approach if issues arise

Output Format

## Implementation Plan: [Feature Name]

### Overview
- **Total tasks:** [N]
- **Estimated complexity:** [S/M/L/XL]
- **Critical path:** Task 1 → Task 3 → Task 5 → Task 7
- **Parallel opportunities:** Tasks 2,4 can run with Task 3

### Task Breakdown

#### Task 1: [Short Title]
- **Status:** PENDING
- **Agent:** backend-developer
- **Complexity:** S
- **Dependencies:** None

**Action:**
[Specific implementation action]

**Files:**
- Create: `src/services/newService.ts`
- Modify: `src/index.ts`

**Verification Gate:**
```bash
npm run typecheck
npm test -- --grep "newService"

Context for Agent:

• •Reference: src/services/existingService.ts for patterns
• •Convention: Use dependency injection
• •Constraint: No external API calls in this task

Task 2: [Short Title]

• •Status: PENDING
• •Agent: database-administrator
• •Complexity: M
• •Dependencies: None (can parallel with Task 1)

Action: [...]

[Continue for all tasks...]

Checkpoint Tasks

Checkpoint A (after Task 4): Integration Test

• •Run: npm run test:integration
• •Verify: API endpoints connect to database
• •If fails: Debug before proceeding

Final Verification

• • All unit tests pass
• • Integration tests pass
• • Type checking passes
• • Linting passes
• • Manual smoke test: [specific scenarios]

Risk Notes

Progress Tracking

Save progress to claude-progress.json:

{
  "feature": "[feature-name]",
  "status": "planned",
  "tasks": {"total": N, "complete": 0}
}

## Agent Assignment Guide

| Task Type | Recommended Agent | When to Use |
|-----------|-------------------|-------------|
| REST API endpoints | backend-developer | Server-side routes, controllers |
| Database schema | database-administrator | Migrations, queries, models |
| React components | react-specialist | UI components, hooks, state |
| TypeScript types | typescript-pro | Complex types, generics |
| Refactoring | refactoring-specialist | Code restructuring |
| Testing | qa-expert | Test cases, coverage |
| Security | security-engineer | Auth, validation, encryption |
| Performance | architect-reviewer | Optimization, caching |

## Task Complexity Guide

| Size | Description | Scope |
|------|-------------|-------|
| S | Single file, straightforward | < 50 lines changed |
| M | Multiple files, clear path | 50-200 lines changed |
| L | Cross-cutting, needs design | 200-500 lines changed |
| XL | Major feature, multiple systems | > 500 lines, split further |

## Best Practices

- Keep tasks small enough to complete in one session
- Every task must have verification criteria
- Include "checkpoint" tasks for integration testing
- Plan for iterative refinement
- Note existing patterns to follow

## Collaboration

After plan approval, invoke the **developing** skill to begin subagent-driven implementation of each task.