feature-planning — Claude Code skill: plans and setup
The feature-planning skill turns feature requests and complex changes into ordered implementation plans with concrete tasks. Use it before coding when the scope needs structure.
Apache-2.0 297 installs ★ 697 updated 2026-07-25
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a claude-codeWhat feature-planning does
feature-planning takes a feature request, enhancement, or multi-step change and turns it into an actionable implementation plan. It first clarifies the goal, users, constraints, and success criteria. It then inspects the repository with the Task tool and the Explore subagent to find existing patterns, related features, and affected code.
The result covers architecture choices, file paths with line references, task dependencies, testing needs, integration points, and edge cases. After the user reviews the plan, the skill can launch plan-implementer for each task in sequence and verify the result before continuing. Test failures go to test-fixing, while commits are handled by git-pushing.
The plan depends on access to the project source and its established patterns. Without repository exploration, file-level references will be less specific.
What it helps with
- turn a feature request into ordered implementation tasks
- map a change to affected files and components
- cover API, UI, database, documentation, and tests
- prepare dependencies for staged implementation
Example prompts for the agent
- Analyze the request for user authentication and create an implementation plan from this repository.
- Plan a data export feature with affected files, dependencies, edge cases, and tests.
- Explore the codebase and break this complex change into sequential tasks with file paths and line references.
How to install feature-planning
1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a claude-code2Manually: put the files in place
~/.claude/skills/feature-planning/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/feature-planning/
1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a codex2Manually: put the files in place
.agents/skills/feature-planning/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a cursor2Manually: put the files in place
.cursor/skills/feature-planning/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install mhattingpete/claude-skills-marketplace engineering-workflow-plugin/skills/feature-planning2Manually: put the files in place
.github/skills/feature-planning/SKILL.md1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a gemini-cli2Platform CLI
gemini skills install https://github.com/mhattingpete/claude-skills-marketplace --path engineering-workflow-plugin/skills/feature-planningManually: put the files in place
.devin/skills/feature-planning/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about feature-planning
How do I install feature-planning in Claude Code?
Run npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a claude-code, then check ~/.claude/skills/feature-planning/SKILL.md.
What does feature-planning do?
It studies a requested feature and the repository, then produces a structured plan with architecture decisions, implementation tasks, dependencies, file references, and test coverage.
Which agents and tools does feature-planning use?
Repository exploration uses the Task tool with the Explore subagent. Approved tasks are passed to plan-implementer; test failures and commits are routed to the related skills.
Source text
SKILL.md · Apache-2.0
---
name: feature-planning
description: Break down feature requests into detailed, implementable plans with clear tasks. Use when user requests a new feature, enhancement, or complex change.
---
# 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**:
```markdown
## 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
© mhattingpete · Apache-2.0 · mhattingpete/claude-skills-marketplace