create-plan

Original：🇨🇳 Chinese

Translated

Create implementation task plans in `_/local-plans/<plan-name>.md`. First investigate the codebase using the Explore Agent, then document it in verifiable granularity and parallel-executable units, following the standard format (Background & Purpose, Current Status, Design, File Structure Tree, Implementation Steps, Verification Methods) that can be validated by the plan-verifier Agent. Used for requests like "Make a plan", "Design", "Task decomposition", "Think about implementation approach". plan, planning, design, implementation plan, task decomposition, create-plan

2installs

Sourcefandhe-ai/agent-cli-skills

Added on2026-05-11

NPX Install

npx skill4agent add fandhe-ai/agent-cli-skills create-plan

SKILL.md Content (Chinese)

View Translation Comparison →

Creating Implementation Plans

Create implementation task plans in

_/local-plans/<plan-name>.md

.

Argument Handling

With arguments → Use the arguments as task description and start creating the plan
Without arguments → Ask the user for task details before starting

Action Principles

Investigate the codebase first — Do not make plans based on assumptions. Use Explore Agent, Glob/Grep to read existing code and understand the current state
Write in verifiable granularity — Each step must have clear completion criteria
Always include file structure — Explicitly list files to be created/modified in tree format
Focus on phase independence — Split into parallel-executable units as much as possible
Write in Japanese — Plan files must be created in Japanese
Write to authenticated locations via
_/
— When creating files in directories that trigger authentication prompts (e.g.,
```
.claude/
```
), first create them temporarily in
```
_/
```
, then move to the target location with
```
mv
```
after completion. During cleanup, only delete files/subdirectories you created, and only delete
```
_/
```
with
```
rmdir
```
if it is empty (Prohibited:
```
rm -rf _/dotclaude
```
— risk of deleting files from concurrent work)

Plan Creation Steps

Step 1: Understand the Task

Analyze the user's description
Investigate the codebase as needed (Explore Agent / Glob / Grep)
- Structure of related existing files
- Technology stack/libraries used
- Existing similar implementations or patterns
- Scope of impact (files affected by changes)
Organize prerequisites and constraints

Step 2: Draft the Plan

Structure the plan according to the following standard format.

Step 3: Create the Plan File

File name: Use a concise kebab-case name that reflects the task content
- Examples:
```
auth-middleware-rewrite.md
```
  ,
```
chakra-ui-skill.md
```
  ,
```
api-endpoint-refactor.md
```
Output location:
```
_/local-plans/<plan-name>.md
```
Report the plan file path to the user

Standard Format (Template)

The plan must be in a format that can be validated by the

plan-verifier

Agent. File structures should be written with full paths, and deliverables for each phase should be clearly stated.

markdown

# {Task Title}

## Background & Purpose

{Why this task is necessary}
{Issues to solve}
{Expected outcomes}

## Current Status

{Relevant current state — existing files, technology stack, dependencies}

## Design

### File Structure

{Tree diagram of files to be created/modified}

### Specifications

{Technical design details — APIs, data structures, formats, etc.}

## Implementation Steps

### Phase 1: {Phase Name}

1. {Specific task}
2. {Specific task}

### Phase 2: {Phase Name}

1. {Specific task}
2. {Specific task}

{Add Phase N as needed}

## Parallel Execution Strategy

{Only include if there are parallelizable tasks}

## Verification Methods

{How to confirm that the plan deliverables are correctly completed}
{Verification points for the plan-verifier Agent}

## Future Enhancements

{Related development possibilities outside the scope — optional}

Notes for Each Section

Background & Purpose: Required. Clearly state why the task is being done
Current Status: Include if there is relevant existing state. Can be omitted if only creating new items
Design: Required. Must include file structure (tree format)
Implementation Steps: Required. Split into phases, each step should be a specific action
Parallel Execution Strategy: Only include if there are parallelizable tasks
Verification Methods: Required. Clearly state how to verify deliverables
Future Enhancements: Optional. Include if there are related items outside the scope