plan

/plan - Adaptive Planning

Create an implementation plan that matches the complexity of the task.

Target: $ARGUMENTS

Workflow

Step 1: Assess Complexity

Search the codebase to understand scope:

# Find affected files
# Estimate lines of code
# Identify dependencies

Classify as:

• TRIVIAL (1-2 files, <50 lines) → Skip planning
• SIMPLE (3-5 files, <200 lines) → Mini-plan
• MEDIUM (6-15 files, complete module) → Standard plan
• COMPLEX (15+ files, multiple modules) → Full design doc

Step 2: Generate Plan

For TRIVIAL:

✓ Task is trivial. Delegating to @builder.

For SIMPLE:

## Quick Plan: [Feature]

1. [Step 1] - `file.ts`
2. [Step 2] - `file.ts`
3. [Step 3] - `file.ts`
4. Test: Run `npm test`
5. Verify: Check [criteria]

Estimated: ~X tokens

For MEDIUM:

## Implementation Plan: [Feature]

### Overview
[2-3 sentences]

### Task Breakdown
- [ ] Task 1: [description] - `file.ts` (~N lines)
- [ ] Task 2: [description] - `file.ts` (~N lines)
- [ ] Task 3: [description] - `file.ts` (~N lines)

### Dependencies
- Task 2 depends on Task 1
- Tasks 3-4 can run in parallel

### Checkpoints
- After Task 2: Verify [condition]
- After Task 4: Run all tests

### Estimated Cost
~X tokens total

For COMPLEX:

## Design Document: [Feature]

### Problem Statement
[What problem are we solving?]

### Requirements
- [ ] Requirement 1
- [ ] Requirement 2

### Current State
[How does the system work today?]

### Proposed Solution
[High-level architecture]

### Alternatives Considered
1. [Alternative] - Rejected: [reason]

### Task Breakdown
[Detailed tasks with estimates]

### Risks
- Risk 1: [mitigation]

### Estimated Cost
~X tokens total

Step 3: Confirm

Ask user: "Approve plan and begin execution?"

If approved, delegate to @executor with the plan.

Output

──── /plan ────
Feature: [name]
Complexity: [TRIVIAL | SIMPLE | MEDIUM | COMPLEX]
Files affected: ~N
Estimated tokens: ~N

[Plan content]

Next: Awaiting approval

Anti-Rationalization

Excuse	Reality
"It's simple enough to just start coding"	That's what every developer says before a 3-day rabbit hole. 10 minutes of planning saves hours.
"I already know the architecture"	Plans aren't just for you - they create alignment and a checkpoint to rollback to.
"Planning is waterfall"	Adaptive planning IS agile. Skipping planning is chaos, not agility.
"I'll refactor later if the approach is wrong"	Refactoring costs 10x more than planning. Get it right first.

Rules

• Never force heavy planning for simple tasks
• Always estimate token costs
• Ask clarifying questions if needed
• Read existing architecture before planning