Create Plan Skill

A Claude Code skill for turning user requirements into structured, actionable implementation plans — scanning context, analyzing scope, identifying risks, and producing step-by-step blueprints before writing any code.

When to Use This Skill

Choose this skill when:

• Starting a new feature and need to scope the work before coding
• Receiving a vague request that needs breakdown into concrete steps
• Planning a migration, refactoring, or architectural change
• Estimating effort and identifying dependencies for a project
• Creating technical specifications or RFCs for team review

Consider alternatives when:

• The task is simple enough to code directly (under 30 minutes)
• You already have a detailed specification to implement
• You need project management with timelines and assignments (use Jira/Linear)

Quick Start

Copy
# Add to your Claude Code project
claude mcp add create-plan

# Generate a plan for a feature
claude "create a plan for adding user authentication to the app"

# Plan a migration
claude "plan the migration from REST to GraphQL for the orders API"

Copy
# .claude/skills/create-plan.yml
name: create-plan
description: Generate structured implementation plans from requirements
triggers:
  - "create plan"
  - "plan the implementation"
  - "scope this feature"
config:
  depth: standard
  include_risks: true
  output_format: markdown

Core Concepts

Planning Workflow

Phase	Action	Output
1. Context Scan	Read relevant files, configs, dependencies	Understanding of current state
2. Requirement Analysis	Break down the request into components	Feature decomposition
3. Dependency Mapping	Identify what depends on what	Dependency graph
4. Risk Assessment	Identify potential blockers and unknowns	Risk register
5. Step Breakdown	Create ordered, actionable implementation steps	Task list
6. Plan Document	Compile into a structured plan	Markdown document

Plan Output Structure

Copy
# Implementation Plan: [Feature Name]

## Summary
One-paragraph description of what will be built and why.

## Scope
- **In scope**: List of what this plan covers
- **Out of scope**: Explicit exclusions to prevent scope creep

## Prerequisites
- [ ] Dependency A must be upgraded to v3.x
- [ ] API keys for service B must be configured

## Implementation Steps
1. **Create database schema** (models/user.ts)
   - Add users table with email, password_hash, created_at
   - Add sessions table with token, user_id, expires_at
   - Create migration file

2. **Build authentication service** (services/authService.ts)
   - Implement signup with password hashing
   - Implement login with JWT token generation
   - Add session validation middleware

3. **Create API endpoints** (routes/auth.ts)
   - POST /api/auth/signup
   - POST /api/auth/login
   - POST /api/auth/logout
   - GET /api/auth/me

## Risks
| Risk | Impact | Mitigation |
|------|--------|------------|
| Password hashing library vulnerability | High | Use bcrypt with cost factor 12 |
| Session token leakage | High | HTTP-only cookies, short expiry |

## Testing Strategy
- Unit tests for auth service logic
- Integration tests for API endpoints
- E2E test for full signup → login → access flow

Configuration

Parameter	Type	Default	Description
depth	string	"standard"	Plan detail level: quick, standard, comprehensive
include_risks	boolean	true	Include risk assessment section
include_testing	boolean	true	Include testing strategy section
include_prerequisites	boolean	true	Include prerequisites checklist
output_format	string	"markdown"	Output format: markdown, json, checklist
max_steps	number	20	Maximum implementation steps
scan_depth	number	3	Directory depth for context scanning

Best Practices

1. Scan the codebase before planning — read existing code patterns, dependencies, and architecture before proposing implementation steps; plans that ignore existing patterns create more work than they save.

2. Define scope boundaries explicitly — always include an "out of scope" section; without clear boundaries, plans expand to cover everything tangentially related and become impossible to execute.

3. Order steps by dependency, not by preference — if step 3 depends on step 1, they must be ordered accordingly; independent steps can be parallelized.

4. Include risks that could derail the plan — every plan should identify at least two concrete risks with mitigations; if you can't think of risks, you haven't thought deeply enough about the implementation.

5. Keep plans actionable and time-bound — each step should be completable in one sitting (2-4 hours); if a step takes longer, break it into smaller steps.

Common Issues

Plan is too detailed and becomes prescriptive — Overly detailed plans constrain the implementer. Focus on what needs to happen and why, not exactly how to write every line of code. Leave room for the developer to make local decisions.

Plan doesn't account for existing code — A plan that proposes creating files that already exist or using patterns inconsistent with the codebase will be ignored. Always scan the project first and align with existing conventions.

Scope keeps growing during planning — Set a firm boundary early. If new requirements emerge during planning, add them to an "out of scope / future work" section rather than expanding the current plan.