Feature Planning

Systematically analyze feature requests and create detailed, actionable implementation plans.

When to Use

• •Requests new feature ("add user authentication", "build dashboard")
• •Asks for enhancements ("improve performance", "add export")
• •Describes complex multi-step changes
• •Explicitly asks for planning ("plan how to implement X")
• •Provides vague requirements needing clarification

Planning Workflow

1. Understand Requirements

Ask clarifying questions:

• •What problem does this solve?
• •Who are the users?
• •Specific technical constraints?
• •What does success look like?

Explore the codebase: Use Task tool with subagent_type='Explore' and thoroughness='medium' to understand:

• •Existing architecture and patterns
• •Similar features to reference
• •Where new code should live
• •What will be affected

2. Analyze & Design

Identify components:

• •Database changes (models, migrations, schemas)
• •Backend logic (API endpoints, business logic, services)
• •Frontend changes (UI, state, routing)
• •Testing requirements
• •Documentation updates

Consider architecture:

• •Follow existing patterns (check CLAUDE.md)
• •Identify reusable components
• •Plan error handling and edge cases
• •Consider performance implications
• •Think about security and validation

Check dependencies:

• •New packages/libraries needed
• •Compatibility with existing stack
• •Configuration changes required

3. Create Implementation Plan

Break feature into discrete, sequential tasks:

## Feature: [Feature Name]

### Overview
[Brief description of what will be built and why]

### Architecture Decisions
- [Key decision 1 and rationale]
- [Key decision 2 and rationale]

### Implementation Tasks

#### Task 1: [Component Name]
- **File**: `path/to/file.py:123`
- **Description**: [What needs to be done]
- **Details**:
  - [Specific requirement 1]
  - [Specific requirement 2]
- **Dependencies**: None (or list task numbers)

#### Task 2: [Component Name]
...

### Testing Strategy
- [What types of tests needed]
- [Critical test cases to cover]

### Integration Points
- [How this connects with existing code]
- [Potential impacts on other features]

Include specific references:

• •File paths with line numbers (src/utils/auth.py:45)
• •Existing patterns to follow
• •Relevant documentation

4. Review Plan with User

Confirm:

• •Does this match expectations?
• •Missing requirements?
• •Adjust priorities or approach?
• •Ready to proceed?

5. Execute with plan-implementer

Launch plan-implementer agent for each task:

Task tool with:
- subagent_type: 'plan-implementer'
- description: 'Implement [task name]'
- prompt: Detailed task description from plan

Execution strategy:

• •Implement sequentially (respect dependencies)
• •Verify each task before next
• •Adjust plan if issues discovered
• •Let test-fixing skill handle failures
• •Let git-pushing skill handle commits

Best Practices

Planning:

• •Start broad, then specific
• •Reference existing code patterns
• •Include file paths and line numbers
• •Think through edge cases upfront
• •Keep tasks focused and atomic

Communication:

• •Explain architectural decisions
• •Highlight trade-offs and alternatives
• •Be explicit about assumptions
• •Provide context for future maintainers

Execution:

• •Implement one task at a time
• •Verify before moving forward
• •Keep user informed
• •Adapt based on discoveries

Integration

• •plan-implementer agent: Receives task specs, implements
• •test-fixing skill: Auto-triggered on test failures
• •git-pushing skill: Triggered for commits