Plan Down

Plan-Down - Method-Driven Four-Path Intelligent Planning Generator

Overview

This skill provides a comprehensive method clarity-driven planning workflow that intelligently adapts to both user interaction preference (Interactive/Automatic) and implementation method clarity (Clear/Unclear).

Core Innovation: Uses zen-mcp chat as decision module to assess whether user provides a "clear implementation method" before planning.

Four Execution Paths:

1. Interactive + Clear: Direct planning with user approval
2. Interactive + Unclear: Multi-round dialogue to clarify method, then plan
3. Automatic + Clear: Fully automated planning
4. Automatic + Unclear: AI chain (clink → chat → consensus) to enrich method, then plan

The final output is a complete plan.md file ready for implementation.

Technical Architecture:

• zen-mcp chat: Method clarity judgment + interactive clarification + deep thinking (via clink)
• zen-mcp planner: Interactive, sequential planning tool with revision and branching capabilities
• zen-mcp consensus: Multi-model method validation (only for Automatic + Unclear path)
• Main Claude Model: Context gathering, workflow orchestration, plan.md generation
• User: Provides ideas/requirements (interactive mode) or none (automatic mode)

New Four-Path Workflow:

User Request → Phase 0 (chat: Method Clear?) → [Conditional Phase 1] → Phase 2 (planner) → Phase 3 (plan.md)
                        ↓                              ↓
                   Clear / Unclear           Clear: Skip to Phase 2
                                            Unclear: Phase 1 (Clarify/Enrich)
                                                    ↓
                                            Interactive: Dialogue with user
                                            Automatic: clink → chat → consensus

Division of Responsibilities:

Phase 0 (Method Clarity Assessment - ALWAYS):

• chat tool: Judge if user provides clear implementation method
• Main Claude: Gather context from CLAUDE.md/PROJECTWIKI.md

Phase 1 (Method Clarification/Enrichment - CONDITIONAL):

• Path A (Interactive + Unclear): chat multi-round dialogue with user to clarify
• Path B (Automatic + Unclear): clink → gemini CLI → chat → consensus → synthesis
• Main Claude: Orchestrate clarification/enrichment process

Phase 2 (Task Decomposition - ALL PATHS CONVERGE):

• planner tool: Task breakdown, milestone definition, dependency mapping, structured planning
• Main Claude: Invoke planner with clear/enriched method

Phase 3 (Final Plan Generation - ALL PATHS):

• Main Claude: Generate and save plan.md directly from planner output (no intermediate review)

When to Use This Skill

Trigger this skill when the user requests:

• "Help me create a plan"
• "Generate plan.md"
• "Use planner for task planning"
• "Help me with task decomposition"
• "Create an implementation plan"
• "Plan the project"
• Any request for systematic planning and task breakdown

Use Cases:

• Feature development planning
• Project implementation roadmaps
• Refactoring strategies
• Migration plans
• Research initiatives
• Complex task breakdowns

Operation Mode (automation_mode - READ FROM SSOT)

automation_mode definition and constraints: See CLAUDE.md「📚 共享概念速查」

This skill's role: Skill Layer (read-only), read from context [AUTOMATION_MODE: true/false]

• false → Interactive: User confirms plan outline before saving
• true → Automated: Auto-approve decisions (plan outline, consensus), log to auto_log.md

Workflow: Intelligent Planning Process with Method Clarity Assessment

Overview: Decision Flow Based on Method Clarity

flowchart TD
    Start[User Request] --> Read[Read automation_mode from context]
    Read --> Judge{Use chat to judge:Method Clear?}

    Judge -->|Clear| Clear[Method Clear]
    Judge -->|Unclear| Unclear[Method Unclear]

    Clear --> CheckMode1{automation_mode?}
    Unclear --> CheckMode2{automation_mode?}

    CheckMode1 -->|false| Path1[Interactive + Clear:planner → plan.md]
    CheckMode1 -->|true| Path2[Automatic + Clear:planner → plan.md]

    CheckMode2 -->|false| Path3[Interactive + Unclear:chat dialogue → planner → plan.md]
    CheckMode2 -->|true| Path4[Automatic + Unclear:clink → chat → consensus → planner → plan.md]

    Path1 --> End[Final plan.md]
    Path2 --> End
    Path3 --> End
    Path4 --> End

Phase 0: Method Clarity Assessment (CRITICAL - First Step)

Main Claude's Action:

1. automation_mode check: [AUTOMATION_MODE: false] → Interactive / true → Automated

1. Gather Initial Context:

a) Read Global Standards (CRITICAL):

• Global CLAUDE.md: /home/vc/.claude/CLAUDE.md - Global rules (G1-G11), phase requirements (P1-P4), model development workflow

b) Read Project-Specific Standards (if exist):

• Project CLAUDE.md: ./CLAUDE.md - Project-specific rules and processes

c) Read Project Documentation:

• PROJECTWIKI.md - Project knowledge base
• README.md - Project overview
• plan.md (if exists) - Existing plan
• docs/adr/*.md - Architecture Decision Records

Standards Priority (when conflicts):

1. Global CLAUDE.md (highest priority)
2. Project CLAUDE.md
3. PROJECTWIKI.md

1. Invoke zen-mcp chat to assess method clarity:

``` Tool: mcp__zen__chat Parameters:

• prompt: "Analyze the following user request and determine if it contains a 'clear implementation method':

User Request: [user's original input]

Collected Project Context:

• Project Type: [from PROJECTWIKI/README]
• Technology Stack: [from context]
• Existing Standards: [from CLAUDE.md]

Judgment Criteria:

• 'Method Clear' = User explicitly stated what to do, how to do it, and what key steps are involved
• 'Method Unclear' = User only provided goals/ideas but lacks specific implementation path

Please output: 'Method Clear' or 'Method Unclear', and briefly explain the reasoning."

• working_directory: "."
• model: "gemini-2.5-pro" (or user-specified model)

```

Output:

• "Method Clear" → Proceed to Phase 2 (Direct Planning)
• "Method Unclear" → Proceed to Phase 1 (Method Clarification/Enrichment)

---

Phase 1: Method Clarification / Enrichment (Conditional - Only if Method Unclear)

This phase is SKIPPED if Phase 0 determined "Method Clear"

Decision Tree Based on automation_mode:

Path A: Interactive Mode (automation_mode = false) + Method Unclear

Main Claude's Action:

Use mcp__zen__chat for multi-round dialogue with user to clarify implementation method:

Tool: mcp__zen__chat
Parameters:
- prompt: "You mentioned wanting to [user's goal]. Let me help you clarify the specific implementation method:

  Current Understanding:
  - Goal: [user's goal]
  - Known Context: [project context]

  Questions to Clarify:
  1. What specific features/steps should be implemented?
  2. What are the priorities?
  3. Are there any technical preferences or constraints?
  4. What are the expected milestones and timeline?

  Please provide more details, and I will help you organize them into a clear implementation plan."

- working_directory: "."
- model: "gemini-2.5-pro"
- continuation_id: [maintain conversation context]

Iteration:

• Continue chat dialogue until user provides clear implementation method
• Main Claude synthesizes user responses into structured requirements
• Once clear → Proceed to Phase 2 (planner)

Output: Clarified implementation method ready for planning

---

Path B: Automatic Mode (automation_mode = true) + Method Unclear

Main Claude's Action - Full Auto-Enrichment Chain:

Step 1: Launch chat via clink for deep thinking

Tool: mcp__zen__clink
Parameters:
- cli_name: "gemini"  # Using gemini CLI for deep analysis
- prompt: "Based on the following vague idea, perform deep thinking and form a clear implementation method:

  User Idea: [user's original input]

  Project Context:
  - Technology Stack: [from context]
  - Existing Architecture: [from PROJECTWIKI]
  - Standard Requirements: [from CLAUDE.md]

  Please think through:
  1. What is the core goal of this idea?
  2. What are the feasible implementation paths?
  3. What are the pros and cons of each path?
  4. Considering the project's current state, what is the best practice method?
  5. What should the key steps and milestones be?

  Output: Structured implementation method (including goals, paths, steps, milestones)"

- role: "default"
- files: [relevant project files]

What Happens:

• clink launches gemini CLI in WSL
• Gemini performs deep thinking about the vague idea
• Returns structured implementation approaches

Step 2: Multi-model consensus evaluation

IMPORTANT: Follow G10 - CLI must be launched first

Tool: mcp__zen__consensus
Parameters:
- step: "Review the following implementation method derived from Gemini's deep thinking:

  [Plan from Step 1]

  Review Points:
  1. Feasibility and completeness of the plan
  2. Alignment with project technology stack and architecture
  3. Compliance with CLAUDE.md standards
  4. Reasonableness of step decomposition
  5. Clarity of milestone settings
  6. Optimization suggestions

  Please provide multi-perspective review feedback."

- step_number: 1
- total_steps: 2
- next_step_required: true
- findings: "Gemini CLI completed deep thinking, generated preliminary plan"
- models: [
    {model: "codex", stance: "against", stance_prompt: "Critically review plan feasibility"},
    {model: "gpt-5-pro", stance: "neutral", stance_prompt: "Objectively assess plan reasonableness"},
  ]
- use_assistant_model: true
- continuation_id: [from clink session if applicable]

What Happens:

• consensus orchestrates multi-model review (uses established CLI session for codex)
• Multiple AI perspectives evaluate and enrich the method
• Consensus synthesis produces optimized implementation approach

Step 3: Synthesize final clear method

Main Claude integrates:

• Original user idea
• Gemini's deep thinking
• Multi-model consensus feedback

Output: Enriched, validated implementation method ready for planning

Decision Logging (Automatic Mode):

[Automated Decision Record]
Decision: Method Unclear → Full auto-enrichment process
Process: clink(gemini) → consensus(codex+gpt-5-pro) → Integrate final plan
Confidence: high
Standards Basis: G11 automation mode rules, use multi-model validation to ensure plan quality
Recorded in auto_log.md

---

Phase 2: Task Decomposition via Planner

Input Source (Depends on Phase 0 Decision):

• If "Method Clear" (Phase 0): Use user's original clear implementation method directly
• If "Method Unclear" (Phase 0 → Phase 1): Use clarified/enriched method from Phase 1
• Interactive Mode (Path A): Clarified through chat dialogue
• Automatic Mode (Path B): Enriched through clink → chat → consensus chain

Main Claude's Action:

Invoke planner tool to perform interactive task breakdown:

Tool: mcp__zen__planner
Parameters:
- step: "Based on the following requirements, perform task decomposition and preliminary planning:

  **Implementation Method** (Source: [Directly from Phase 0 / Clarified/Enriched in Phase 1]):
  [User's clear implementation method OR Phase 1 clarification/enrichment result]

  Goal: [Extracted from implementation method]
  Scope: [Extracted from implementation method]
  Constraints: [Extracted from implementation method]

  **Standards to Follow (CRITICAL):**
  [Key rules extracted from Global CLAUDE.md, such as G1-G11 and core principles]
  [Project-specific rules extracted from Project CLAUDE.md (if any)]

  Examples:
  - G1: Documentation First-Class Citizen - Code changes must synchronize PROJECTWIKI.md and CHANGELOG.md updates
  - G2: Knowledge Base Strategy - Use Mermaid for architecture diagrams, API definitions consistent with code
  - G8: plan.md must be generated using plan-down skill
  - CLAUDE.md Principle 2: Reproducibility - Must create model cards/run records

  Please create a detailed task decomposition plan, including:
  1. Major milestones and phases
  2. Specific tasks for each phase
  3. Dependencies between tasks
  4. Estimated effort and time
  5. Potential risks and mitigation measures
  6. Acceptance criteria
  7. **Specific measures to comply with CLAUDE.md standards**

  Organize tasks using a clear hierarchical structure."

- step_number: 1
- total_steps: 3 (Initial estimate: Problem understanding → Preliminary planning → Refinement)
- next_step_required: true
- model: "gemini-2.5-pro" (or user-specified model)
- use_assistant_model: true (Enable expert model for planning validation)

planner execution: Receives requirements → Interactive sequential planning (task → phases → dependencies → risks → timeline) → Supports revision/branching → Returns complete plan structure

Output: Complete plan structure ready for final generation

Note on Workflow Simplification:

In the new four-path design, consensus evaluation of planner output is NO LONGER needed. The workflow proceeds directly from planner to final plan.md generation:

• All four paths: planner → plan.md (no intermediate consensus review)
• Rationale:
• planner already has built-in expert model validation (useassistantmodel=true)
• For "Automatic + Unclear" path, consensus was already used in Phase 1 to validate the implementation method
• Removing redundant review step improves efficiency while maintaining quality

If user requests revision during planner execution:

• Use planner's revision capability (set is_step_revision: true)
• Or create alternative branch (set is_branch_point: true)

---

Phase 3: Final Plan Generation (Direct from Planner)

Why Direct Generation:

In the new four-path workflow, we skip the intermediate consensus review of planner output because:

1. planner already has validation: Built-in expert model validation (useassistantmodel=true)
2. Consensus used earlier (for Automatic + Unclear path): Already validated the implementation method in Phase 1
3. Efficiency: Eliminates redundant review step while maintaining quality
4. All paths converge here: planner → plan.md

Main Claude's Action:

Generate final plan.md directly from planner output:

1. Synthesize Plan Structure:

• Use planner's complete plan structure
• For "Automatic + Unclear" path: Implementation method was already validated by consensus in Phase 1
• For all paths: planner's expert validation (useassistantmodel=true) ensures quality

1. Structure plan.md:

# Plan: [Project/Task Name]

## Objective
[Clear objective description]

## Scope
### In-Scope
- [Item 1]
- [Item 2]

### Out-of-Scope
- [Non-goal 1]
- [Non-goal 2]

## Standards Compliance

### Global Standards
**Source**: `/home/vc/.claude/CLAUDE.md`

**Key Rules**:
- **G1 - Documentation First-Class Citizen**: Code changes must synchronize PROJECTWIKI.md and CHANGELOG.md updates
- **G2 - Knowledge Base Strategy**: Use Mermaid for architecture diagrams, API definitions consistent with code
- **G4 - Consistency and Quality**: Ensure API and data models are consistent with code implementation
- **CLAUDE Principle 2 - Reproducibility**: Create model cards/run records, including environment, dependencies, hyperparameters
- **CLAUDE Principle 3 - Baseline First**: Start with simple models, then complex models

### Project-Specific Standards
**Source**: `./CLAUDE.md` (if exists)

- [Project-specific rule 1]
- [Project-specific rule 2]

### Compliance Measures in This Plan:
- [ ] Each code change phase includes documentation update tasks
- [ ] Use Mermaid to draw architecture and process diagrams
- [ ] Create model cards (if involving machine learning)
- [ ] Follow Conventional Commits specification
- [ ] [Other proj

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [VCnoC](https://github.com/VCnoC)
- **Source:** [VCnoC/Claude-Code-Zen-mcp-Skill-Work](https://github.com/VCnoC/Claude-Code-Zen-mcp-Skill-Work)
- **License:** Apache-2.0

Install and usage instructions live in the source repository linked above.