create-plan
Generate detailed implementation plans for complex tasks. Creates comprehensive strategic plans in Markdown format with objectives, step-by-step implementation tasks using checkbox format, verification criteria, risk assessments, and alternative approaches. All plans MUST be validated using the included validation script. Use when users need thorough analysis and structured planning before implementation, when breaking down complex features into actionable steps, or when they explicitly ask for a plan, roadmap, or strategy. Strictly planning-focused with no code modifications.
Best use case
create-plan is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Generate detailed implementation plans for complex tasks. Creates comprehensive strategic plans in Markdown format with objectives, step-by-step implementation tasks using checkbox format, verification criteria, risk assessments, and alternative approaches. All plans MUST be validated using the included validation script. Use when users need thorough analysis and structured planning before implementation, when breaking down complex features into actionable steps, or when they explicitly ask for a plan, roadmap, or strategy. Strictly planning-focused with no code modifications.
Teams using create-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/create-plan/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How create-plan Compares
| Feature / Agent | create-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?
Generate detailed implementation plans for complex tasks. Creates comprehensive strategic plans in Markdown format with objectives, step-by-step implementation tasks using checkbox format, verification criteria, risk assessments, and alternative approaches. All plans MUST be validated using the included validation script. Use when users need thorough analysis and structured planning before implementation, when breaking down complex features into actionable steps, or when they explicitly ask for a plan, roadmap, or strategy. Strictly planning-focused with no code modifications.
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
Generate comprehensive implementation plans that provide strategic guidance without making actual code changes.
## When to Use
- User explicitly requests a plan, roadmap, or implementation strategy
- Complex tasks requiring structured breakdown before implementation
- Need for risk assessment and alternative approach analysis
- Pre-implementation analysis of architectural decisions
## Planning Process
### 1. Initial Assessment
Research the codebase to understand:
- Project structure and organization
- Relevant files and components
- Existing patterns and conventions
- Potential challenges and risks
Use `search` and `read` tools to examine the codebase. Use `sage` if deeper research is required for the use-case. Explicitly cite sources using `filepath:line` format.
### 2. Create Strategic Plan
Generate a Markdown plan file in `plans/` directory with naming: `plans/{YYYY-MM-DD}-{task-name}-v{N}.md`
Example: `plans/2025-11-24-add-auth-v1.md`
### 3. Validate Plan
**MANDATORY:** Run the validation script to ensure the plan meets all requirements:
```bash
./.forge/skills/create-plan/validate-plan.sh plans/{YYYY-MM-DD}-{task-name}-v{N}.md
```
Fix any errors or warnings and re-validate until the plan passes all checks.
### 4. Plan Structure
```markdown
# [Task Name]
## Objective
[Clear statement of goal and expected outcomes]
## Implementation Plan
- [ ] 1. [First task with detailed description and rationale]
- [ ] 2. [Second task with detailed description and rationale]
- [ ] 3. [Third task with detailed description and rationale]
## Verification Criteria
- [Criterion 1: Specific, measurable outcome]
- [Criterion 2: Specific, measurable outcome]
## Potential Risks and Mitigations
1. **[Risk Description]**
Mitigation: [Specific mitigation strategy]
2. **[Risk Description]**
Mitigation: [Specific mitigation strategy]
## Alternative Approaches
1. [Alternative 1]: [Brief description and trade-offs]
2. [Alternative 2]: [Brief description and trade-offs]
```
## Critical Requirements
- **ALWAYS validate the plan** using `./.forge/skills/create-plan/validate-plan.sh` after creation
- **ALWAYS use checkbox format** (`- [ ]`) for ALL implementation tasks
- **NEVER use numbered lists** or plain bullet points in Implementation Plan section
- **NEVER write code, code snippets, or code examples** in the plan
- Include clear rationale for each task
- Provide specific, measurable verification criteria
- Document assumptions made for ambiguous requirements
- Focus on strategic "what" and "why", not tactical "how"
- Describe what needs to be done using natural language, not code
## Best Practices
- Make reasonable assumptions when requirements are ambiguous
- Use codebase patterns to infer best practices
- Provide multiple solution paths for complex challenges
- Balance thoroughness with actionability
- Create plans that can be executed step-by-step by implementation agents
## Boundaries
This is a **planning-only** skill:
- ✅ Research codebase and analyze structure
- ✅ Create strategic plans and documentation
- ✅ Assess risks and propose alternatives
- ✅ Describe implementations using natural language
- ❌ Make actual code changes
- ❌ Modify files or create implementations
- ❌ Run tests or build commands
- ❌ Write code, code snippets, or code examples in plans
If user requests implementation work, suggest switching to an implementation agent.Related Skills
writing-plans
Use when design is complete and you need detailed implementation tasks for engineers with zero codebase context - creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps assuming engineer has minimal domain knowledge
treatment-plans
Generate concise (3-4 page), focused medical treatment plans in LaTeX/PDF format for all clinical specialties. Supports general medical treatment, rehabilitation therapy, mental health care, chronic disease management, perioperative care, and pain management. Includes SMART goal frameworks, evidence-based interventions with minimal text citations, regulatory compliance (HIPAA), and professional formatting. Prioritizes brevity and clinical actionability.
system-createcli
Generate production-quality TypeScript CLIs with full documentation, error handling, and best practices. Creates deterministic, type-safe command-line tools following PAI's CLI-First Architecture. USE WHEN user says "create a CLI", "build a command-line tool", "make a CLI for X", or requests CLI generation. (user)
story-explanation
Create compelling story-format summaries using UltraThink to find the best narrative framing. Support multiple formats - 3-part narrative, n-length with inline links, abridged 5-line, or comprehensive via Foundry MCP. USE WHEN user says 'create story explanation', 'narrative summary', 'explain as a story', or wants content in Daniel's conversational first-person voice.
sales-comp-plan-designer
Base/variable split recommendations, accelerators, decelerators, quota retirement methods, SPIFs, cost of sales tracking.
project-planning
Generate structured planning documentation for web projects with context-safe phases, verification criteria, and exit conditions. Creates IMPLEMENTATION_PHASES.md plus conditional docs (DATABASE_SCHEMA, API_ENDPOINTS, UI_COMPONENTS, CRITICAL_WORKFLOWS). Use when: starting new Cloudflare Workers/React projects, adding major features to existing apps, breaking large work into manageable phases, or need verified planning before coding begins.
execute-plan
Execute structured task plans with status tracking. Use when the user provides a plan file path in the format `plans/{current-date}-{task-name}-{version}.md` or explicitly asks you to execute a plan file.
create-skill
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends your capabilities with specialized knowledge, workflows, or tool integrations.
create-skill-file
Guides Claude in creating well-structured SKILL.md files following best practices. Provides clear guidelines for naming, structure, and content organization to make skills easy to discover and execute.
create-plans
Create hierarchical project plans optimized for solo agentic development. Use when planning projects, phases, or tasks that Claude will execute. Produces Claude-executable plans with verification criteria, not enterprise documentation. Handles briefs, roadmaps, phase plans, and context handoffs.
zapier-workflows
Manage and trigger pre-built Zapier workflows and MCP tool orchestration. Use when user mentions workflows, Zaps, automations, daily digest, research, search, lead tracking, expenses, or asks to "run" any process. Also handles Perplexity-based research and Google Sheets data tracking.
writing-skills
Create and manage Claude Code skills in HASH repository following Anthropic best practices. Use when creating new skills, modifying skill-rules.json, understanding trigger patterns, working with hooks, debugging skill activation, or implementing progressive disclosure. Covers skill structure, YAML frontmatter, trigger types (keywords, intent patterns), UserPromptSubmit hook, and the 500-line rule. Includes validation and debugging with SKILL_DEBUG. Examples include rust-error-stack, cargo-dependencies, and rust-documentation skills.