From soloflow
Guides structured clarification of high-level project visions before roadmap generation. Checks 8 readiness criteria, decomposes multi-product scopes, and probes one question at a time.
How this skill is triggered — by the user, by Claude, or both
Slash command
/soloflow:clarify-roadmapThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
This skill encodes a deep conversational clarification loop to run **before** roadmap research and generation, when the user provides a high-level project vision that needs structured decomposition. It is **instructional** -- the calling command drives the loop using its own `AskUserQuestion` tool. This skill does not spawn subagents.
This skill encodes a deep conversational clarification loop to run before roadmap research and generation, when the user provides a high-level project vision that needs structured decomposition. It is instructional -- the calling command drives the loop using its own AskUserQuestion tool. This skill does not spawn subagents.
Apply this checklist to the raw input. If any item is missing or unclear, invoke the loop:
If all eight are present, skip this skill and proceed directly to research. Running the loop on an already-clear input is a cost, not a benefit.
Opt-out signals the caller must honor:
--skip-clarify anywhere in the argumentsconfig.phases.roadmap_clarify === false in .soloflow/config.json or config/defaults.yaml"The user already knows what they want."
A roadmap shapes months of work. The checklist is the judge, not your intuition. Cheap to run, expensive to skip.
If the input spans multiple independent products (e.g., "build a marketplace AND a separate analytics dashboard AND a mobile companion app"), stop immediately. Do NOT begin clarification on the whole thing.
Use AskUserQuestion:
Roadmap only the selected product. The others can be roadmapped separately later.
Note: Unlike clarify-idea, which decomposes subsystems, this gate decomposes at the product level. A single product with multiple subsystems is fine -- the roadmap generator will phase those into epics.
Rules (hard):
AskUserQuestion at a time. Never batch clarification questions. Each answer informs the next question.WebSearch for unfamiliar domain terms or stack questions is fine to frame better candidate answers. Never use research as a substitute for asking the user.Keep going until the checklist at the top of this file is satisfied -- every item has a clear answer.
Once you believe the checklist is satisfied, present an explicit confirmation via AskUserQuestion:
You MUST NOT proceed to research/generation until "Generate roadmap" is selected. This is a hard gate -- the anti-pattern is declaring readiness yourself and skipping the user confirmation.
If the user picks "Keep clarifying," return to the clarification loop. There is no retry limit; loop until the user confirms.
When the gate passes, produce a roadmap brief in this exact shape and hand it to the caller:
## Raw Input
{Verbatim $ARGUMENTS the user passed in}
## Clarification Transcript
- Q: {question 1}
A: {user answer 1}
- Q: {question 2}
A: {user answer 2}
{...}
## Synthesis
### Vision
{One paragraph restating what the finished product looks like and why it matters}
### Target Users
{Who they are, their pain points, what success looks like for them}
### Constraints
{Timeline, budget, team, platform, regulatory -- everything that bounds the solution space}
### Success Metrics
{How success will be measured, in order of priority}
### Technical Preferences
{Stack, hosting, integrations, non-negotiable tech choices}
### Scope Boundary
{What is explicitly out of scope}
### Phasing Priorities
{What ships first and why, hard deadlines if any}
### Risk Tolerance
{New tech appetite, incremental vs big-bang shipping preference}
The Synthesis sections are canonical. The raw input and transcript are context only.
This skill is designed to be invoked by /soloflow:roadmap. It could also be reused by any future command that needs deep project-level questioning before planning.
npx claudepluginhub kesteva/soloflow --plugin soloflow-devGuides product managers through strategic roadmap planning: prioritization, epic definition, stakeholder alignment, and release sequencing. Use to turn strategy into an actionable release plan.
Assesses task complexity upfront (quick/standard/full) and brainstorms with adaptive depth: ~2 exchanges for bugs, full PRD for complex features. Use for unclear requirements or new ideas.
Guides project ideation via Socratic questioning, constraint discovery, and structured phases to generate actionable project briefs comparing alternative approaches. Use for new projects without clear requirements.