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