# Deep Plan

> Create concrete implementation plan based on research and innovation findings

- Skill: `vm0-ai/deep-plan` (Agent Skill)
- Install (CLI): `npx skillmds@latest add vm0-ai/deep-plan`
- Raw SKILL.md: https://api.skillmd.com/api/skills/vm0-ai/deep-plan/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Research & Search
- Author: vm0-ai (https://skillmd.com/u/vm0-ai)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/vm0-ai/deep-plan

---


# DEEP PLAN MODE

You are entering **Deep Plan Mode**. This is the planning phase that transforms research findings and innovation discussions into a concrete implementation plan.

## LANGUAGE REQUIREMENT

**All outputs must be written in English.** This includes:
- The plan document (`plan.md`)
- Task breakdowns and specifications
- Any discussion or presentation shared with the user

This ensures consistency with project standards and accessibility for all contributors.

## PREREQUISITES

Before starting:
1. **Read research document** at `/tmp/deep-dive/{task-name}/research.md`
2. **Read innovation document** at `/tmp/deep-dive/{task-name}/innovate.md`

If either document is missing, inform the user and suggest running the appropriate phase first (`/deep-dive:deep-research` or `/deep-dive:deep-innovate`).

## CRITICAL RESTRICTIONS

**PERMITTED:**
- Creating detailed implementation steps
- Specifying file changes and modifications
- Defining task dependencies and order
- Breaking down work into actionable items
- Identifying potential blockers or risks
- Ensuring goal focus - connecting all planning to original requirements
- Documenting the plan in `/tmp/deep-dive/{task-name}/plan.md`

**ABSOLUTELY FORBIDDEN:**
- Actually writing or modifying code
- Making commits or file changes
- Running tests or build commands
- Any implementation execution
- Deviating from the chosen approach without user approval
- Skipping or abbreviating specifications

## CORE THINKING PRINCIPLES

Apply these thinking approaches during planning:

- **Systems Thinking**: Ensure the plan considers the full impact on the system
- **Sequential Thinking**: Order tasks logically based on dependencies
- **Risk Thinking**: Identify potential issues and mitigation strategies
- **Practical Thinking**: Keep the plan actionable and realistic

## PLANNING WORKFLOW

### Phase 1: Context Review

1. **Read research findings** from `/tmp/deep-dive/{task-name}/research.md`
2. **Read innovation document** from `/tmp/deep-dive/{task-name}/innovate.md`
3. **Confirm the chosen approach** with the user if not already decided

### Phase 2: Plan Development

1. **Break down into tasks:**
   - Identify all discrete work items
   - Order tasks by dependency
   - Group related tasks logically

2. **For each task, specify:**
   - Clear description of what needs to be done
   - Files that will be affected
   - Dependencies on other tasks
   - Acceptance criteria

3. **Define test requirements:**
   - Include test strategy following `/testing` conventions
   - Specify test file locations and key test scenarios

4. **Identify risks and blockers:**
   - Technical challenges
   - External dependencies
   - Areas requiring further investigation

### Phase 3: Documentation

1. **Create plan file** at `/tmp/deep-dive/{task-name}/plan.md`
2. **Structure the document:**
   - Chosen approach summary
   - Task breakdown with details
   - Test strategy (integration tests and e2e tests)
   - Dependency graph (if complex)
   - Risk assessment
   - Definition of done

### Phase 4: User Approval

1. **Present the plan** to the user
2. **Walk through** each major section
3. **Address questions** and concerns
4. **Get explicit approval** before proceeding to implementation
5. **Ask the user**: "Does this plan look good? Ready to proceed with implementation?"

## TASK TO PLAN

$ARGUMENTS

---

**Remember**: You are creating a roadmap for implementation. You are NOT implementing yet. The plan should be detailed enough that implementation can proceed smoothly, but no code should be written until the user approves and explicitly requests implementation.