Method clarity-driven planning workflow using zen-mcp tools (chat, planner, consensus). Phase 0 uses chat to judge if user provides clear implementation method. Four execution paths based on automation_mode × method clarity - Interactive/Automatic × Clear/Unclear. All paths converge at planner for task decomposition. Produces complete plan.md file. Use when user requests "create a plan", "generate plan.md", "use planner for planning", "help me with task decomposition", or similar planning tasks.
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:
The final output is a complete plan.md file ready for implementation.
Technical Architecture:
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):
Phase 1 (Method Clarification/Enrichment - CONDITIONAL):
Phase 2 (Task Decomposition - ALL PATHS CONVERGE):
Phase 3 (Final Plan Generation - ALL PATHS):
Trigger this skill when the user requests:
Use Cases:
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 savingtrue → Automated: Auto-approve decisions (plan outline, consensus), log to auto_log.mdflowchart TD
Start[User Request] --> Read[Read automation_mode from context]
Read --> Judge{Use chat to judge:<br/>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:<br/>planner → plan.md]
CheckMode1 -->|true| Path2[Automatic + Clear:<br/>planner → plan.md]
CheckMode2 -->|false| Path3[Interactive + Unclear:<br/>chat dialogue → planner → plan.md]
CheckMode2 -->|true| Path4[Automatic + Unclear:<br/>clink → chat → consensus → planner → plan.md]
Path1 --> End[Final plan.md]
Path2 --> End
Path3 --> End
Path4 --> End
Main Claude's Action:
automation_mode check: [AUTOMATION_MODE: false] → Interactive / true → Automated
Gather Initial Context:
a) Read Global Standards (CRITICAL):
/home/vc/.claude/CLAUDE.md - Global rules (G1-G11), phase requirements (P1-P4), model development workflowb) Read Project-Specific Standards (if exist):
./CLAUDE.md - Project-specific rules and processesc) Read Project Documentation:
Standards Priority (when conflicts):
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:
This phase is SKIPPED if Phase 0 determined "Method Clear"
Decision Tree Based on automation_mode:
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:
Output: Clarified implementation method ready for planning
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:
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:
Step 3: Synthesize final clear method
Main Claude integrates:
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
Input Source (Depends on Phase 0 Decision):
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:
If user requests revision during planner execution:
is_step_revision: true)is_branch_point: true)Why Direct Generation:
In the new four-path workflow, we skip the intermediate consensus review of planner output because:
Main Claude's Action:
Generate final plan.md directly from planner output:
Synthesize Plan Structure:
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 project-specific compliance measures]
## Milestones
1. [ ] **[Milestone 1]** - [Estimated completion time]
- [Key deliverables]
2. [ ] **[Milestone 2]** - [Estimated completion time]
- [Key deliverables]
## Task Breakdown
### Phase 1: [Phase Name]
**Goal**: [Phase objective]
**Estimated Duration**: [X days/weeks]
- [ ] **Task 1.1**: [Task description]
- Dependencies: [None / Task X.X]
- Estimated Effort: [X hours/days]
- Acceptance Criteria: [Clear completion criteria]
- [ ] **Task 1.2**: [Task description]
- Dependencies: Task 1.1
- Estimated Effort: [X hours/days]
- Acceptance Criteria: [Clear completion criteria]
### Phase 2: [Phase Name]
...
## Dependencies
```mermaid
graph TD
A[Task 1.1] --> B[Task 1.2]
B --> C[Task 2.1]
C --> D[Milestone 1]
| Risk | Impact | Probability | Mitigation | |------|--------|-------------|-----------| | [Risk 1] | High/Medium/Low | High/Medium/Low | [Mitigation measure] | | [Risk 2] | High/Medium/Low | High/Medium/Low | [Mitigation measure] |
3. **Save to File:**
- Use Write tool to save to `./plan.md`
- Or user-specified path
- Default filename: `plan.md`
**Output:** Complete plan.md file saved to disk
---
### Phase 4: Post-Planning Actions (Optional)
**Main Claude's Action (if requested by user):**
1. **Create Task Tracking:**
- Extract tasks into GitHub Issues
- Create project board
- Set up milestones
2. **Generate Summary:**
- One-page executive summary
- Gantt chart (Mermaid)
- Timeline visualization
3. **Integration with Project Wiki:**
- Link plan.md to PROJECTWIKI.md
- Update "Design Decisions & Technical Debt" section
- Add to CHANGELOG.md
---
## Complete Workflow Examples
### Example 1: Path 1 - Interactive + Clear Method
**User Request:**
Help me create an implementation plan for a user registration feature.
Implementation Method:
**Workflow:**
Phase 0: chat judges → "Method Clear" (User explicitly stated 5 steps) ↓ Phase 2: planner receives clear method → task decomposition ↓ Phase 3: Generate plan.md
**Main Claude Actions:**
- Phase 0: Invoke `mcp__zen__chat` → Returns "Method Clear"
- Phase 2: Invoke `mcp__zen__planner` with the 5-step method
- Phase 3: Generate and save plan.md
**automation_mode: false** → User confirms plan outline before saving
---
### Example 2: Path 2 - Interactive + Unclear Method
**User Request:**
Help me create a plan to improve system performance. I feel the system is too slow right now.
**Workflow:**
Phase 0: chat judges → "Method Unclear" (Only goal, lacks specific method) ↓ Phase 1A: chat multi-round dialogue with user User clarifies: Performance bottleneck is in database queries, need to optimize frontend loading, considering introducing cache ↓ Main Claude synthesizes: Clear three-phase optimization method ↓ Phase 2: planner receives clarified method → task decomposition ↓ Phase 3: Generate plan.md
**Main Claude Actions:**
- Phase 0: Invoke `mcp__zen__chat` → Returns "Method Unclear"
- Phase 1A: Multiple `mcp__zen__chat` calls (dialogue)
- Q1: "Where is the performance bottleneck? Database, frontend, or backend?"
- User: "Mainly slow database queries, and frontend loading has some issues too"
- Q2: "Are you considering introducing a cache? Redis or other solutions?"
- User: "Redis is an option"
- Synthesis: Form clear database optimization + frontend optimization + cache solution
- Phase 2: Invoke `mcp__zen__planner` with clarified method
- Phase 3: Generate and save plan.md
**automation_mode: false** → User participates in clarification dialogue
---
### Example 3: Path 3 - Automatic + Clear Method
**User Request (with "full automation" keyword):**
Full automation mode: Help me create a CI/CD process optimization plan.
Implementation Method:
**Workflow:**
Phase 0: chat judges → "Method Clear" ↓ Phase 2: planner receives clear method → task decomposition ↓ Phase 3: AUTO-generate plan.md (no user approval needed)
**Main Claude Actions:**
- Phase 0: Invoke `mcp__zen__chat` → Returns "Method Clear"
- Phase 2: Invoke `mcp__zen__planner` with the 5-step method
- Phase 3: Auto-generate plan.md → Log decision to auto_log.md
[Automated Decision Record] Decision: Method clear and complete, auto-approved and generated plan.md Confidence: high Standards Basis: User provided 5 explicit steps, complies with CLAUDE.md planning requirements Recorded in auto_log.md
**automation_mode: true** → All decisions auto-approved
---
### Example 4: Path 4 - Automatic + Unclear Method (MOST COMPLEX)
**User Request (with "full automation" keyword):**
Full automation mode: Help me design an intelligent recommendation system. I want to recommend content that users might be interested in.
**Workflow:**
Phase 0: chat judges → "Method Unclear" (Only idea, lacks implementation path) ↓ Phase 1B: Auto-enrichment chain (no user interaction) Step 1: clink → gemini CLI (deep thinking) Gemini analyzes: Multiple implementation paths for recommendation system - Collaborative filtering - Content-based recommendation - Hybrid recommendation Gemini proposes: Implementation plan using hybrid recommendation method ↓ Step 2: consensus multi-model review codex (critical): Evaluate technical feasibility gpt-5-pro (neutral): Balanced assessment Synthesis: Optimized implementation plan ↓ Step 3: Main Claude synthesizes final method ↓ Phase 2: planner receives enriched method → task decomposition ↓ Phase 3: AUTO-generate plan.md
**Main Claude Actions:**
**Phase 0:**
Tool: mcp__zen__chat Output: "Method Unclear" - Only has the idea of recommendation system, lacks implementation path
**Phase 1B - Step 1 (Deep Thinking via clink):**
Tool: mcp__zen__clink Parameters:
Google Workspace CLI for Gmail, Calendar, Drive, Contacts, Sheets, and Docs.
Manage Apple Notes via the `memo` CLI on macOS (create, view, edit, delete, search, move, and export notes). Use when a user asks OpenClaw to add a note, list notes, search notes, or manage note folders.
Work with Obsidian vaults (plain Markdown notes) and automate via obsidian-cli.
Use when you need to control Slack from OpenClaw via the slack tool, including reacting to messages or pinning/unpinning items in Slack channels or DMs.
Manage Apple Reminders via remindctl CLI (list, add, edit, complete, delete). Supports lists, date filters, and JSON/plain output.
Manage Trello boards, lists, and cards via the Trello REST API.
Category:productivity