plan
Create a detailed implementation plan for a feature or task. Use when user wants to plan before coding.
Best use case
plan is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Create a detailed implementation plan for a feature or task. Use when user wants to plan before coding.
Teams using plan should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/plan/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How plan Compares
| Feature / Agent | plan | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Create a detailed implementation plan for a feature or task. Use when user wants to plan before coding.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Create Implementation Plan
Create an implementation plan for $ARGUMENTS.
## Planning Process
### 1. Requirements Analysis
First clarify:
- **Purpose**: What to achieve
- **Scope**: What to include, what to exclude
- **Constraints**: Technical, time, dependencies
### 2. Current State Investigation
Investigate the codebase:
```
- Related existing code
- Files affected
- Libraries/patterns to use
- Existing tests
```
### 3. Break Down Implementation Steps
Break into small steps:
1. Each step is independently testable
2. Consider dependency order
3. High-risk steps first
### 4. Output Format
```markdown
## Implementation Plan: {Title}
### Purpose
{1-2 sentences}
### Scope
- New files: {list}
- Modified files: {list}
- Dependencies: {list}
### Implementation Steps
#### Step 1: {Title}
- [ ] {Specific task}
- [ ] {Specific task}
**Verification**: {Completion criteria for this step}
#### Step 2: {Title}
...
### Risks & Considerations
- {Potential issues and mitigations}
### Open Questions
- {Items to clarify before implementation}
```
## Notes
- Plans should be at actionable granularity
- Include verification method for each step
- Ask questions at planning stage for unclear points
- Don't over-detail (adjust during implementation)Related Skills
context-loader
ALWAYS activate this skill at the start of every task. Load project context from .claude/ directory including coding rules, design decisions, and documentation before executing any task.
update-lib-docs
Update library documentation in .claude/docs/libraries/ with latest information from web search.
update-design
Explicitly update DESIGN.md with decisions from the current conversation. Use when you want to force a design document update.
troubleshoot
Diagnose and plan fixes for errors/bugs with Codex-first multi-agent collaboration (Codex + Opus 4.6 + Agent Teams). Codex CLI is consulted in EVERY phase for deep code reasoning, hypothesis evaluation, and fix validation. Phase 1: Error reproduction & context gathering (Opus subagent 1M context + Codex initial analysis + Claude user interaction). Phase 2: Parallel diagnosis (Agent Teams: Root Cause Analyst [Codex-driven] + Impact Investigator [Opus + Codex risk analysis]). Phase 3: Fix plan synthesis, Codex validation & user approval. Fix implementation is handled separately by /team-implement.
team-review
Parallel code review using Agent Teams. Spawns specialized reviewers (security, quality, test coverage) to review implementation from different perspectives simultaneously. Run after implementation.
team-implement
Parallel implementation using Agent Teams. Spawns teammates per module/layer, each owning separate files to avoid conflicts. Uses shared task list with dependencies for autonomous coordination. Run after /start-feature plan approval.
tdd
Implement features using Test-Driven Development (TDD) with Red-Green-Refactor cycle.
start-feature
Start a new feature with multi-agent collaboration (Opus 4.6 + Agent Teams). Phase 1: Codebase understanding (Opus subagent 1M context + Claude user interaction). Phase 2: Parallel research & design (Agent Teams: Researcher + Architect). Phase 3: Plan synthesis & user approval. Implementation is handled separately by /team-implement.
spike
Time-boxed technical investigation/feasibility study with Codex-first multi-agent collaboration (Codex + Opus 4.6 + Agent Teams). Codex CLI is consulted in EVERY phase for question framing, feasibility analysis, and final evaluation. Phase 1: Frame the investigation question & constraints (Claude user interaction + Codex question decomposition). Phase 2: Parallel investigation (Agent Teams: Researcher [Opus external research] + Feasibility Analyst [Codex deep analysis] + optional prototype). Phase 3: Codex synthesis into go/no-go recommendation & research report. Produces a DECISION DOCUMENT, NOT an implementation plan. Use /add-feature or /start-feature after a GO decision.
simplify
Simplify and refactor code while preserving functionality and library constraints.
research-lib
Research a library and create comprehensive documentation in .claude/docs/libraries/.
init
Analyze project structure and populate the "Repository Identity" section of CLAUDE.md (Zone B) plus AGENTS.md.