Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mhattingpete/claude-skills-marketplace --skill feature-planning -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/feature-planning/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/feature-planning/

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set15

The whole set →
code-auditor code-auditor walks a repository through architecture, code quality, security, performance, testing and maintainability, then hands back a report. Useful when you inherit code and need to know what hurts. CX Codex +1 344installs dashboard-creator dashboard-creator builds a single-page HTML dashboard with KPI cards, charts, progress bars and data tables. Handy when you need to show metrics without a frontend framework. CX Codex +1 337installs timeline-creator timeline-creator turns a project's tasks and dates into an interactive HTML timeline with Gantt bars, phases and milestones. Handy when a plan has to live in one file. CX Codex +1 337installs code-refactor code-refactor is a Claude Code skill for bulk code changes across files: renaming variables and functions, replacing deprecated patterns, and updating API calls. It automatically selects a mode that saves up to 90% of tokens for 10+ files. CX Codex +1 304installs code-execution The code-execution skill runs Python locally for bulk file work, code analysis, transformations, and Git tasks. It fits large or multi-step workflows. CX Codex +1 294installs conversation-analyzer conversation-analyzer analyzes your local Claude Code session logs to detect recurring errors, repetitive prompts, and workflow bottlenecks. CX Codex +1 249installs technical-doc-creator technical-doc-creator builds HTML documentation for APIs and systems with code samples, architecture diagrams, syntax highlighting, and workflow steps. CX Codex +1 221installs ensemble-solving ensemble-solving spawns three parallel subagents to explore diverse solutions, scores each approach against weighted criteria, and returns the best outcome with trade-offs. CX Codex +1 218installs

Project sponsors

Companies that keep this analytics open