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