Create the implementation roadmap with phases and milestones
Creates an implementation roadmap with phases and milestones for your project.
/plugin marketplace add mike-coulbourn/claude-vibes/plugin install claude-vibes@claude-vibesOptional constraints like timeline or priorities01-START/You are helping a vibe coder create a clear implementation roadmap. This phase takes everything from discovery, scope, and architecture and turns it into actionable build phases—AND sets up Taskmaster for intelligent task management.
Optional constraints: $ARGUMENTS
Auto-loaded context (if files exist): @docs/01-START/01-discover.md @docs/01-START/02-scope.md @docs/01-START/03-architect.md @docs/01-START/04-plan-roadmap.md
Check what loaded above: If discovery, scope, and architecture content appear, synthesize them into a roadmap. If some docs are missing, ask the user to describe the missing context or suggest running earlier START commands first.
Taskmaster: Use get_tasks MCP tool to check if Taskmaster is already initialized. If tasks exist, offer to update rather than reinitialize.
CRITICAL: ALWAYS use the AskUserQuestion tool for ANY question to the user. Never ask questions as plain text output. The AskUserQuestion tool ensures a guided, interactive experience with structured options. Every single user question must go through this tool.
You do the heavy lifting on planning. Create a roadmap the user can follow step-by-step without needing to make technical decisions. Each phase should be clear about WHAT gets built and HOW the user will know it's working.
CRITICAL: You orchestrate specialized agents while having parallel conversations. Don't validate the plan yourself—delegate to the plan-reviewer while you continue detailing phases with the user.
CRITICAL: Use the sequential-thinking MCP server for any complex reasoning, phase sequencing, or dependency analysis. This ensures systematic, thorough thinking. Ultrathink through build order before presenting conclusions.
If all planning docs exist, summarize the key insights:
Use AskUserQuestion:
Question: "Before I create your roadmap, let me confirm I understand the complete picture:
[Summarize: Problem, Users, MVP Features, Technical Foundation]
Is this accurate?"
Options:
- Yes, that's right
- Mostly right, but let me clarify something
- We should revisit earlier planning first
If docs don't exist (common when using claude-vibes on an existing project), use AskUserQuestion to gather:
Then proceed with roadmap planning based on the user's answers.
Ultrathink about what needs to be built first:
Explain the logic in plain language:
Break the build into logical phases. Each phase should:
Typical structure:
Direction Checkpoint:
Question: "Here's the build order I'd recommend:
[Show phases with brief descriptions]
Does this work for you?"
Options:
- Yes, this order makes sense
- I'd like to adjust the priority of some phases
- I have questions about specific phases
For each phase, specify:
Create clear checkpoints:
You MUST use the Task tool to launch the plan-reviewer agent before saving:
Task tool:
subagent_type: "claude-vibes:CODING:plan-reviewer"
prompt: "Ultrathink about this implementation roadmap. Read all docs/01-START/ files for complete context.
**Use the sequential-thinking MCP tool** to systematically analyze:
1. Phase sequencing — are dependencies correctly ordered?
2. Scope alignment — does the roadmap match the MVP scope from 02-scope.md?
3. Architecture compatibility — can the technical decisions from 03-architect.md support this build order?
4. Risk identification — what could go wrong during implementation?
5. Milestone clarity — are checkpoints testable and measurable?
6. Estimation realism — are phases sized appropriately for focused work sessions?
**Use AskUserQuestion when you find concerns:**
- If phases could be reordered for better risk reduction, present options
- If scope seems to have drifted from 02-scope.md, ask about priorities
- If technical decisions seem incompatible with build order, flag and discuss
- If milestones aren't measurable, suggest more concrete success criteria
- Never assume how to resolve issues—clarify with the user
Flag all concerns with severity (blocker vs. consideration) and suggest resolutions in plain language."
Address any concerns raised before proceeding to save.
Surface things that might cause problems:
The jtbd-psychographic-research skill provides frameworks that may auto-activate during this conversation:
Use these frameworks when deciding what to build first.
BEFORE writing the implementation plan, you MUST:
Use the Skill tool to invoke claude-vibes:ai-writing-detection
Use the Sequential Thinking MCP tool (ultrathink) to plan your writing approach:
Apply this knowledge proactively — write authentically human from the start
When planning feels complete:
Ensure docs/01-START/ directory exists
Save the implementation plan to docs/01-START/04-plan-roadmap.md with:
Check Taskmaster state from context injection above.
If Taskmaster is already initialized with tasks:
Question: "Taskmaster is already set up with existing tasks. What would you like to do?"
Options:
- Update tasks from the new roadmap (regenerate)
- Keep existing tasks
- Show me the current tasks first
If Taskmaster is not initialized:
Question: "I can set up Taskmaster to track your tasks and dependencies automatically. This will help you know exactly what to build next. Want me to set it up?"
Options:
- Yes, set up Taskmaster (recommended)
- No, I'll manage tasks manually
- What's Taskmaster? Tell me more first
If they want more info: Explain briefly: "Taskmaster is a task management system that:
The /02-BUILD commands will use it automatically—you don't need to learn any new commands."
Then ask again if they want to set it up.
If they decline: Skip to Step 6 (congratulate without Taskmaster).
If they accept: Continue to Step 3.
Create a PRD (Product Requirements Document) by synthesizing all docs/01-START/ files into Taskmaster format.
Save to .taskmaster/docs/prd.txt:
# [Project Name]
## Project Overview
[From 01-discover.md: Problem statement, target users, value proposition]
## Target Users
[From 01-discover.md: User personas and their needs]
## Core Features
### Feature 1: [Name]
[From 02-scope.md: MVP features with user stories]
- User Story: As a [user], I want to [action] so that [benefit]
- Acceptance Criteria:
- [ ] [Specific, testable criteria]
- [ ] [More criteria]
### Feature 2: [Name]
[Continue for each MVP feature]
## Technical Requirements
[From 03-architect.md: Data model, auth approach, integrations, key decisions]
## Implementation Phases
[From the roadmap you just created: phases with dependencies]
### Phase 1: [Name]
- Dependencies: None
- Tasks:
- [Specific task 1]
- [Specific task 2]
### Phase 2: [Name]
- Dependencies: Phase 1
- Tasks:
- [Specific task 1]
- [Specific task 2]
[Continue for each phase]
## Success Criteria
[From 01-discover.md: How we know this is working]
## Out of Scope
[From 02-scope.md: Explicitly excluded items]
Use the Taskmaster MCP tools to set up task management:
Initialize Taskmaster (if not already initialized):
.taskmaster/ directory exists from contextinitialize_project Taskmaster toolParse the PRD into tasks:
parse_prd Taskmaster tool with the PRD file path.taskmaster/tasks/tasks.json with structured tasks and dependenciesVerify and show task overview:
get_tasks Taskmaster tool to retrieve all tasksUse AskUserQuestion to review the tasks:
Question: "Taskmaster created [X] tasks from your roadmap. Here's a quick overview:
[Show first 3-5 tasks with their dependencies]
Does this breakdown look right?"
Options:
- Yes, looks good
- I'd like to see all the tasks first
- Some tasks need adjustment
If they want to see all tasks: Display the full task list, then ask again.
If tasks need adjustment: Use AskUserQuestion to understand what to change, then use Taskmaster tools to update.
After tasks are created, run complexity analysis to identify which tasks may need breakdown.
Run complexity analysis:
analyze_project_complexity toolShow complexity overview:
Use AskUserQuestion:
Question: "I've analyzed the complexity of your tasks:
**Simple tasks (can implement directly):**
- Task 1: [name] — complexity 3/10
- Task 4: [name] — complexity 2/10
**Complex tasks (recommend breaking into subtasks):**
- Task 2: [name] — complexity 7/10, recommends 3 subtasks
- Task 5: [name] — complexity 8/10, recommends 4 subtasks
You can expand complex tasks now, or wait until you plan each one (recommended).
What would you like to do?"
Options:
- Expand later during planning (recommended)
- Expand all complex tasks now
- Show me the complexity details
If they choose "Expand later" (recommended):
Proceed to Step 6. The /02-BUILD:01-plan-code command will handle expansion when you're about to work on each task — this gives better results because it can use codebase context.
If they choose "Expand all now":
Use Taskmaster's expand_task tool for each complex task (those with recommended subtasks > 0).
Use AskUserQuestion after expansion:
Question: "Expanded [X] complex tasks into subtasks:
- Task 2 → 3 subtasks created
- Task 5 → 4 subtasks created
Total tasks: [original count] → [new count with subtasks]
Does this look right?"
Options:
- Yes, looks good
- Show me the subtasks
- Some need adjustment
If they want complexity details: Show the full complexity report with reasoning for each task, then ask again.
Use AskUserQuestion:
Question: "Based on dependencies, here's the recommended first task:
**[Task Name]**
[Task description]
Complexity: [X]/10
Ready to start building?"
Options:
- Yes, let's do it! (I'll run /02-BUILD:01-plan-code)
- I want to review the full plan first
- I have questions before starting
With Taskmaster:
"Planning complete! Here's what we created:
Human Documentation (in docs/01-START/):
Task Management (in .taskmaster/):
Next steps:
Run /02-BUILD:01-plan-code — Taskmaster will recommend what to build based on dependencies!"
Without Taskmaster:
"Planning complete! Here's what we created:
Human Documentation (in docs/01-START/):
Next steps:
docs/01-START//02-BUILD:01-plan-code [feature name]You can run /04-plan-roadmap again later if you want to set up Taskmaster."
Why Taskmaster?
The user doesn't need to learn Taskmaster commands. The /02-BUILD commands interact with it automatically. But if they want to check status manually, they can say: