Skip to content
Skills Library
Programming · Planning

create-plan

/create-plan

Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests like "create a plan", "plan the implementation", "design how to implement", or when given a feature/task that needs structured planning before implementation.

Licence
MIT
Last repository change
13.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
2
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests like "create a plan", "plan the implementation", "design how to implement", or when given a feature/task that needs structured planning before implementation.

Triggers from the description

create a planplan the implementationdesign how to implement
Original author description

Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests like "create a plan", "plan the implementation", "design how to implement", or when given a feature/task that needs structured planning before implementation.

How it works

  1. Contents
  2. When to Use This Skill
  3. Initial Input Handling
  4. Planning Workflow
  5. Multi-Session Support
  6. Critical Guidelines
  7. Quality Checklist
  8. Progress Tracking
  9. Project Type Detection
Original SKILL.md headings · 440 lines, 1,978 words
SKILL.md preview
---
name: create-plan
description: Create detailed implementation plans through interactive research and iteration. This skill should be used when creating new implementation plans, designing feature specifications, planning technical work, or when the user asks to plan an implementation. Triggers on requests like "create a plan", "plan the implementation", "design how to implement", or when given a feature/task that needs structured planning before implementation.
---

# Create Plan

<!-- contents: generated by tests/skill_structure.py --write; edit headings, not this block -->
## Contents

- [When to Use This Skill](#when-to-use-this-skill)
- [Initial Input Handling](#initial-input-handling)
- [Planning Workflow](#planning-workflow)
  - [Phase 1: Research](#phase-1-research)
  - [Phase 2: Present Understanding](#phase-2-present-understanding)
  - [Phase 3: Research User Corrections](#phase-3-research-user-corrections)
  - [Phase 4: Design Options](#phase-4-design-options)
  - [Phase 4b: Document Decision (ADR)](#phase-4b-document-decision-adr)
  - [Phase 5: Phase Structure Review](#phase-5-phase-structure-review)
  - [Phase 6: Write the Plan](#phase-6-write-the-plan)
  - [Phase 7: Bootstrap Tasks](#phase-7-bootstrap-tasks)
- [Multi-Session Support](#multi-session-support)
- [Critical Guidelines](#critical-guidelines)
  - [Verification-First Planning](#verification-first-planning)
  - [Be Thorough](#be-thorough)
  - [Be Interactive](#be-interactive)
  - [Be Skeptical](#be-skeptical)
  - [Exit Conditions Are Blocking Gates](#exit-conditions-are-blocking-gates)
  - [No Unresolved Questions](#no-unresolved-questions)
- [Quality Checklist](#quality-checklist)
- [Progress Tracking](#progress-tracking)
- [Project Type Detection](#project-type-detection)

Reference files (open one when a step points to it):
- `references/exit-conditions.md`: Exit Condition Templates by Project Type
<!-- /contents -->

Create detailed, well-researched implementation plans through interactive collaboration and thorough codebase investigation.

## When to Use This Skill

- Planning new features or functionality
- Designing technical implementations before coding
- Creating phased development roadmaps
- Structuring complex refactoring work
- Any task requiring upfront planning and design

## Initial Input Handling

Parse the user's request to identify:

1. **Task description** - What needs to be implemented
2. **Context files** - Relevant existing code or documentation
3. **Constraints** - Timeline, technology, or scope limitations

| Scenario | Action |
|----------|--------|
| Parameters provided | Read all referenced files completely, then proceed to Research |
| Missing task description | Ask: "What feature or functionality should I plan?" |
| No context provided | Ask: "Are there existing files or documentation I should review?" |

## Planning Workflow

### Phase 1: Research

**Critical**: Thoroughly investigate the codebase before planning.

Spawn parallel sub-tasks using specialized agents:

```
Research Tasks:
- codebase-locator: Find all files related to the feature area
- codebase-analyzer: Understand existing patterns and architecture
- Explore: Investigate integration points and dependencies
```

For each research task, provide:
- Specific directories to examine
- Exact patterns or code to find
- Required output: file:line references

**Read all identified files completely** - no partial reads or summaries.

### Phase 2: Present Understanding

Before any design work, present findings:

1. **Codebase Analysis**
   - Relevant existing code with file:line references
   - Current patterns and conventions discovered
   - Integration points and dependencies

2. **Clarifying Questions**
   - Ask only questions that code investigation couldn't answer
   - Focus on business logic, user requirements, edge cases
   - Avoid questions answerable by reading more code

Wait for user response before proceeding.

### Phase 3: Research User Corrections

**Critical**: Do not accept user corrections at face value.

When the user provides corrections or additional context:
1. Verify claims through code investigation
2. Cross-reference with discovered patterns
3. Resolve any conflicts between user input and codebase reality

If conflicts exist, present findings and discuss before proceeding.

### Phase 4: Design Options

Present design approaches with trade-offs:

```
Option A: [Approach Name]
- Description: [How it works]
- Pros: [Benefits]
- Cons: [Drawbacks]
- Fits pattern: [Reference to existing codebase patterns]

Option B: [Alternative Approach]
- Description: [How it works]
- Pros: [Benefits]
- Cons: [Drawbacks]
- Fits pattern: [Reference to existing codebase patterns]

Recommendation: [Preferred option with rationale]
```

Wait for user feedback on approach before detailing phases.

### Phase 4b: Document Decision (ADR)

**Before creating a new ADR**, check for existing related decisions:

```
# Tiered ADR reading (context conservation)
1. Read("docs/decisions/INDEX.md")           # Scan all ADRs
2. Read("docs/decisions/ADR-NNNN.md", limit=10)  # Quick Reference only
3. Read full ADR only if directly relevant
```

**After user approves a design option**, invoke the ADR skill to document the decision:

```
Skill(skill="adr"): Document the design decision just made.

Context: [Why this decision was needed - from research phase]
Options Considered: [List options from Phase 4]
Decision: [The chosen option]
Rationale: [Why this option was selected]
Consequences: [Expected impacts]
```

The ADR will be created at `docs/decisions/ADR-NNNN-title.md` and INDEX.md will be updated.

**Update the plan** to reference the ADR in the Design Decision section:

```markdown
## Design Decision

[Brief description of chosen approach]

See [ADR-NNNN](../decisions/ADR-NNNN-title.md) for full rationale and alternatives considered.
```

**When to create ADRs during planning:**
- Choosing between architectural approaches
- Selecting technologies or libraries
- Establishing new patterns or conventions
- Making trade-offs with significant implications
- Decisions that future developers will question "why?"

### Phase 5: Phase Structure Review

Before writing the detailed plan, present proposed phases. The right number of phases depends on the scope of work, but a common mistake is creating too few — lumping multiple distinct concerns into a single phase makes implementation harder, verification muddier, and rollback riskier.

**Phase granularity guidelines:**

- **One concern per phase.** If a phase touches unrelated subsystems (e.g., "set up database AND build API AND add auth"), split it. Each phase should have a single, clear objective that can be verified independently.
- **Think in layers.** A natural decomposition often follows: foundation/setup → data model → core logic → API/interface → integration → polish/edge cases. Each layer is a phase.
- **Each phase should be demonstrably working** when complete. If you can't write a concrete verification for a phase in isolation, it's probably bundled with something else.
- **Prefer more smaller phases over fewer large ones.** Smaller phases are easier to implement, review, test, and debug. They also give the user more checkpoints to course-correct.

```
Proposed Implementation Phases:

Phase 1: [Name] - [Brief description]
Phase 2: [Name] - [Brief description]
Phase 3: [Name] - [Brief description]
Phase 4: [Name] - [Brief description]
Phase 5: [Name] - [Brief description]
...

Does this structure make sense? Any phases to add/remove/reorder?
```

Get explicit approval before writing the full plan.

### Phase 6: Write the Plan

Write the implementation plan to the designated location:

**Default path**: `docs/plans/YYYY-MM-DD-description.md`

Use this structure:

```markdown
# Implementation Plan: [Feature Name]

## Overview
[2-3 sentence summary of what will be implemented]

## Context
[Background, motivation, relevant existing code references]

## Design Decision
[Chosen approach and rationale]

**ADR Reference**: [ADR-NNNN](../decisions/ADR-NNNN-title.md)

## Related ADRs
- [ADR-NNNN](../decisions/ADR-NNNN-title.md): [Brief description of relevance]

## Implementation Phases

### Phase 1: [Name]

**Objective**: [What this phase accomplishes]

**Verification Approach**: [How will we verify this phase works? What tests, commands, or checks will confirm success?]

**Tasks** (tests first, then implementation):
- [ ] Write tests: [test file] covering [scenarios]
- [ ] Implement: [file] to make tests pass
- [ ] Verify: [specific check or command]

**Exit Conditions**:

> Phase cannot proceed until ALL conditions pass.

Build Verification:
- [ ] `[build command]` succeeds
- [ ] `[lint command]` passes
- [ ] `[typecheck command]` passes (if applicable)

Runtime Verification:
- [ ] Application starts: `[start command]`
- [ ] No runtime errors in console
- [ ] [Service/endpoint] is accessible at [URL]

Functional Verification:
- [ ] `[test command]` passes
- [ ] [Specific test]: `[targeted test command]`
- [ ] [Manual check]: [Observable behavior to verify]

### Phase 2: [Name]
[Continue pattern...]

## Dependencies
[External dependencies, prerequisites, blockers]

## Risks and Mitigations
[Potential issues and how to handle them]
```

### Phase 7: Bootstrap Tasks

After writing the plan file, create Tasks for progress tracking:

**Process:**
1. Generate a task list ID from plan filename: `plan-{filename-without-extension}`
   - Example: `2026-01-24-user-auth.md` → `plan-2026-01-24-user-auth`

2. Create a Task for each phase:
   ```
   TaskCreate:
     subject: "Phase N: [Phase Name]"
     description: "[Phase objective] - Plan: [plan file path]"
     activeForm: "Implementing Phase N: [Name]"
   ```

3. Set sequential dependencies:
   ```
   TaskUpdate:
     taskId: [phase-N]
     addBlockedBy: [phase-(N-1)]  # Each phase blocked by previous
   ```

4. Add task list ID to plan metadata (top of file):
   ```markdown
   ---
   task_list_id: plan-2026-01-24-user-auth
   ---
   ```

**Completion Message:**
```
Plan created: [path]
Tasks created: [count] phases with sequential dependencies
Task List ID: [task_list_id]

To work on this plan:
  Single session:  /implement-plan [path]
  Multi-session:   CLAUDE_CODE_TASK_LIST_ID=[task_list_id] claude

Use the same task_list_id across sessions to share progress.
```

## Multi-Session Support

Tasks persist on the filesystem and can be shared across Claude Code sessions.

**Starting a shared session:**
```bash
CLAUDE_CODE_TASK_LIST_ID=plan-2026-01-24-user-auth claude
```

**Benefits:**
- Multiple developers can work on the same plan
- Progress syncs automatically via shared task list
- Dependency tracking prevents conflicts (blocked tasks visible)
- Resume from any session with the same task_list_id

**Task States:**
```
◻ #1 Phase 1: Setup
◻ #2 Phase 2: Core Logic › blocked by #1
◻ #3 Phase 3: Integration › blocked by #2
◻ #4 Phase 4: Testing › blocked by #3
```

## Critical Guidelines

### Verification-First Planning

Every phase in the plan MUST include:

1. **Verification Approach** - A clear statement of how success will be measured
2. **Tests before implementation** - Task lists must show test creation BEFORE implementation
3. **Specific test scenarios** - Not just "write tests" but what scenarios to cover

Example:
```markdown
**Verification Approach**: Unit tests verify password hashing and comparison.
Integration test confirms login endpoint accepts valid credentials and rejects invalid ones.

**Tasks** (tests first, then implementation):
- [ ] Write tests: `auth.service.spec.ts` covering hash generation, hash comparison, invalid inputs
- [ ] Write tests: `auth.controller.spec.ts` covering login success, login failure, missing credentials
- [ ] Implement: `auth.service.ts` - password hashing utilities
- [ ] Implement: `auth.controller.ts` - login endpoint
- [ ] Verify: `npm test -- auth` passes
```

### Be Thorough
- Read entire files, not partial content
- Verify facts through code investigation
- Follow import chains to understand dependencies

### Be Interactive
- Get buy-in at each step
- Allow course corrections throughout
- Present options rather than dictating

### Be Skeptical
- Research user claims before accepting
- Cross-reference multiple sources
- Challenge assumptions with evidence

### Exit Conditions Are Blocking Gates

Exit conditions are **mandatory gates** that must pass before advancing to the next phase. They are not advisory - they are requirements.

**Three Verification Categories** (all must pass):

1. **Build Verification** - Code compiles and passes static analysis:
   - Build commands (`npm run build`, `cargo build`, `go build`)
   - Linting (`npm run lint`, `flake8`, `golangci-lint`)
   - Type checking (`npm run typecheck`, `mypy`, `tsc --noEmit`)

2. **Runtime Verification** - Application actually runs:
   - Start command executes without error
   - No runtime exceptions or crashes
   - Services/endpoints become accessible
   - Health checks pass

3. **Functional Verification** - Correct behavior:
   - Test suites pass (`npm test`, `pytest`, `go test`)
   - Specific feature tests pass
   - Manual verification steps (for human-observable behaviors)

**Never skip a category** - each phase must have at least one check in each category.

### No Unresolved Questions

**Do NOT write plans with open questions.**

If planning encounters ambiguity:
1. Stop and research further
2. Present options to the user
3. Get resolution before continuing

A plan with "TBD" or "to be determined" sections is incomplete.

## Quality Checklist

Before finalizing any plan:

- [ ] All relevant code has been read completely
- [ ] File:line references are accurate and specific
- [ ] Design fits existing codebase patterns
- [ ] Phases are incrementally implementable
- [ ] Each phase has a Verification Approach section
- [ ] Tasks list tests BEFORE implementation
- [ ] Exit conditions cover all three verification categories
- [ ] No unresolved questions or TBD sections
- [ ] User has approved structure and approach
- [ ] Tasks bootstrapped with dependencies set
- [ ] task_list_id added to plan metadata

## Progress Tracking

Progress is tracked via **Task tools** which persist across sessions. See [ADR-0001](../../docs/decisions/ADR-0001-separate-plan-spec-from-progress-tracking.md).

**Task Persistence:**
- Tasks persist on filesystem between sessions
- Dependencies ensure correct execution order
- Multiple sessions can share the same task list via `CLAUDE_CODE_TASK_LIST_ID`

**Workflow:**
```
create-plan → TaskCreate (all phases) → Outputs task_list_id
                    ↓
implement-plan → TaskUpdate(in_progress) → implement-phase → TaskUpdate(completed)
                    ↓
Resume (any session) → CLAUDE_CODE_TASK_LIST_ID=xxx claude → TaskList shows progress
```

## Project Type Detection

Before writing exit conditions, detect the project type and use appropriate commands. Read `references/exit-conditions.md` for detection heuristics and per-language templates (Node.js, Python, Go, Rust, Java, etc.).
Files in this package (2)
  • SKILL.md 15 KB
  • references/exit-conditions.md 3 KB

Versions

RepositoryScoreLicence
This page · mhylle/claude-skills-collection100MIT
drosam/agents100MIT
tzachbon/srulik-toolkit100MIT
atomicinnovation/accelerator100MIT
jkaloger/lazyspec100MIT
yonatangross/orchestkit100MIT
davila7/claude-code-templates100MIT
humansintheloop-dev/humansintheloop-dev-workflow-and-tools100Apache-2.0
flc1125/skills100MIT

Database snapshot: 13.11.2026 · package version 30ddd346ff4f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100writing-plans
    Use when you have a spec, design doc, or requirements and need a detailed implementation plan before coding. Triggers: 'write a plan', 'create implementation plan', 'plan this out', 'break this down into steps', 'convert design to tasks', 'implementation order'. Also invoked by…
  • 100rails-cto-architect
    How to write comprehensive implementation plans for multi-step Rails features before any code is written. Use when the user has a spec, feature request, or multi-step task and wants to plan the approach before touching code. Also use when the user mentions "create a plan",…
  • 95Plan
    Generate implementation plans from feature specifications with foundation-aware template selection, dependency analysis, and phased execution strategy. USE WHEN plan, implementation plan, how to implement, execution plan, technical approach, planning, create plan.
  • 100writing-plans
    Write structured implementation plans from specs or requirements before touching code. Use when given a spec, requirements doc, or feature description, when user says "plan this out", "write a plan for", "how should we implement", or before starting any multi-step coding task.
  • 100sdd-planning
    Generate technical plans from specifications. Use when creating architecture documents, designing system components, or preparing for implementation.
  • 100plan
    Create a detailed implementation plan for a feature or task. Use when user wants to plan before coding.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.