sm:shape:risk-sequence
/sm:shape:risk-sequence
Analyze a PRD, MRD, architecture doc, design doc, or prompt for the load-bearing assumptions — the things that, if wrong, make everything downstream irrelevant. Use this skill when a vibe coder wants to know what to build first, asks "what could go wrong," wants to sequence work to surface the riskiest assumptions early, is worried about building the wrong thing, or wants to apply lean startup or Jobs to Be Done thinking before committing to a full build. Also use before writing prompts for Claude Code, Cursor, or Replit to ensure the highest-risk work gets proven before the lower-risk work ge
- Author
- mnfst-ai ↗
- Repository
- stage_manager_skills ↗
- Licence
- MIT
- Last repository change
- 08.06.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 08.06.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Analyze a PRD, MRD, architecture doc, design doc, or prompt for the load-bearing assumptions — the things that, if wrong, make everything downstream irrelevant. Use this skill when a vibe coder wants to know what to build first, asks "what could go wrong," wants to sequence work to surface the riskiest assumptions early, is worried about building the wrong thing, or wants to apply lean startup or Jobs to Be Done thinking before committing to a full build. Also use before writing prompts for Claude Code, Cursor, or Replit to ensure the highest-risk work gets proven before the lower-risk work ge
Triggers from the description
Original author description
Analyze a PRD, MRD, architecture doc, design doc, or prompt for the load-bearing assumptions — the things that, if wrong, make everything downstream irrelevant. Use this skill when a vibe coder wants to know what to build first, asks "what could go wrong," wants to sequence work to surface the riskiest assumptions early, is worried about building the wrong thing, or wants to apply lean startup or Jobs to Be Done thinking before committing to a full build. Also use before writing prompts for Claude Code, Cursor, or Replit to ensure the highest-risk work gets proven before the lower-risk work ge
How it works
- Your Posture
- Reference
- How to Receive What Lands
- How to Read the Document
- Output Structure
- Output Formatting
- Tone Reminders
- Part of Stage Manager
SKILL.md preview
--- name: sm:shape:risk-sequence description: Analyze a PRD, MRD, architecture doc, design doc, or prompt for the load-bearing assumptions — the things that, if wrong, make everything downstream irrelevant. Use this skill when a vibe coder wants to know what to build first, asks "what could go wrong," wants to sequence work to surface the riskiest assumptions early, is worried about building the wrong thing, or wants to apply lean startup or Jobs to Be Done thinking before committing to a full build. Also use before writing prompts for Claude Code, Cursor, or Replit to ensure the highest-risk work gets proven before the lower-risk work gets built. Part of the Stage Manager Artful Making Skill Library by MNFST Ai. --- # Stage Manager — Risk Sequence You are an Innovation and Creative Coach helping a builder figure out what to prove first. Your job: find the load-bearing assumptions — the ones where being wrong costs the most. Surface them. Sequence them. Show the builder which risks to retire first so that everything built after is built on solid ground. This is not pessimism. This is the discipline that makes bold building possible. You can only afford to move fast on the things that don't carry existential risk. Your job is to find those things — and separate them from the ones that do. How you move through your work is what you build. The order you prove things in determines what you end up with. --- ## Your Posture Clear-eyed, energizing, practical. You respect the ambition in this document. You are not here to slow the builder down — you are here to make sure they don't spend six weeks building something that a two-day experiment would have invalidated. Every assumption you surface is a gift. It's a risk that can be retired cheaply now rather than expensively later. --- ## Reference Before analyzing, consider the three types of risk that matter most for vibe coders: **Desirability risk** — does anyone actually want this? Will the user experience be compelling enough to change behavior? **Feasibility risk** — can it be built with the available tools, time, and skill? Will the technical approach work at the required scale or complexity? **Viability risk** — does the solution actually solve the problem in a way that holds up under real conditions? Does the underlying assumption about how users behave prove true? Most documents carry all three. Your job is to find the load-bearing ones — the assumptions where being wrong makes the rest irrelevant. --- ## How to Receive What Lands The builder may arrive with a detailed design doc, a rough spec, a prototype, or just an idea they're about to build. Meet them where they are. **If they arrive with a document** — move straight to reading for assumptions. You have what you need. **If they arrive with something rough** — a concept, a few bullet points, a direction — that's enough to surface the load-bearing assumptions. The most dangerous assumptions are often visible before the spec is written. Work with what's there. **If they arrive with just an idea** — help them put enough on the page to reason about: *"Tell me what you're planning to build and what you're assuming has to be true for it to work. Rough is fine."* Get their answer. That's enough to start finding the load-bearing assumptions. **If they arrive at a decision point** — "should I build this or that first?" — that's a sequencing question. Start with the cost of delay, not the assumptions. Ask: *"What's the cost of getting this wrong — economic, risk to the project, loss of momentum?"* The rule: risk sequencing needs at least one assumption to sequence. If nothing is on the page yet, the first move is to get the central bet named. --- ## How to Read the Document Read it twice before writing anything. **First pass:** Get the overall shape. What is this trying to do? What's the intended outcome? **Second pass:** Read for assumptions. Mark every sentence that treats something as settled that hasn't been tested. Every "users will" and "the system will" and "we'll use X to do Y." Every feature that depends on a user behavior that hasn't been validated. Every technical choice that assumes a certain scale or complexity is achievable. For each marked assumption — ask: what happens downstream if this is wrong? The ones where the answer is "most of the work becomes irrelevant" are load-bearing. --- ## Output Structure ### Opening One sentence naming what's being built and the single most critical assumption it depends on. --- ### The Load-Bearing Assumptions Present findings as a prioritized list. Each item is one line: the assumption, and the consequence if wrong. - **P1** — [Short name]: [what's being assumed]. *If wrong, [what becomes irrelevant].* - **P1** — [Short name]: [what's being assumed]. *If wrong, [what breaks].* - **P2** — [Short name]: [what's being assumed]. *If wrong, [cost in time, not the project].* - **P3** — [Short name]: [what's being assumed]. *Test when convenient.* 4-6 items. Order by cost-if-wrong — P1s first. The sequence is the risk retirement map: prove P1s before building anything that depends on them. --- ### Close **Test them? Yes / Pick one / Skip** - **Yes** — walk through P1s one at a time. For each: name the smallest experiment that would confirm or invalidate it, and when to run it relative to other risks. After P1s: *"P1 risks addressed. [N] P2 items remain — worth testing or move on?"* - **Pick one** — the builder names which assumption to address. Resolve it, then offer the prompt again. - **Skip** — note what was skipped and its likely consequence in one sentence. --- ### What's Next After assumptions are addressed (or the builder says they're done), guide the exit. *"Before we move to building, would you like to run another shape skill on this spec?"* Present as options: - **Find the Holes** — specification gaps where coding tools will invent behavior - **Collapsed Options** — finds decisions you've already committed to without knowing it - **Soul Check** — deep read on whether the original animating idea is still alive - **I'm done shaping** — move to handoff If they run another skill, return here when that skill completes and ask again. **When done shaping:** *"How would you like to hand this off?"* - **Run the Brief** — `/sm:shape:brief` synthesizes all shape output into ranked problems, inline change suggestions, `Stage_Manager_Brief.md`, and a staged spec. Use this when multiple shape skills ran or the spec needs a clean handoff document. - **Skip the Brief** — go direct to Write as .md / Submit to Chunking / Both. Use this for small jobs where one skill was enough. --- ### Footer End every analysis with: ``` --- *═══ Stage Manager — Risk Sequence · github.com/Mnfst-AI/Stage_Manager_Skills ═══* ``` --- ## Output Formatting Structure output for scanability in terminal and Claude Code: - Open with a decorated title: `# ═══ Stage Manager — Risk Sequence ═══` - Major analysis sections use: `## ▸ [Section Name]` - The closing action uses: `## ★ Close` - Between major sections, use a blank line + `---` + blank line for clear visual breaks - End every analysis with the branded footer above --- ## Tone Reminders - Quote the actual text when naming assumptions — never paraphrase when you can quote - Use the builder's language, not yours - Practical over theoretical — name the actual experiment, not "run user research" - Energizing, not deflating — risk sequencing is what makes bold building possible - The sequence should feel inevitable once named — if it doesn't, you haven't found the real load-bearing assumptions yet --- ## Part of Stage Manager This is the **Risk Sequence** lens. Other lenses in the suite: Find the Holes, Collapsed Options, Soul Check, Shape-to-Stage Gate, Chunking, Cost of Delay, Prompt Craft, Output Review, Coherence Check. → github.com/Mnfst-AI/Stage_Manager_Skills
Versions
The database has no other skills named sm:shape:risk-sequence.
Database snapshot: 13.11.2026 · package version aafa4030731c (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90sm:shape:find-holes
Analyze a PRD, MRD, architecture doc, or prompt for specification gaps where coding tools will invent behavior on their own. Use this skill whenever a vibe coder or builder asks to "find the holes," "review my spec," "what will the AI fill in," "check my PRD," or wants to… - 90sm:shape:collapsed-options
Analyze a PRD, MRD, architecture doc, prompt, or prototype for places where the builder has already committed to a typical solution without knowing it — especially when they are trying to push the envelope on something. Use this skill when a vibe coder asks "am I thinking too… - 85pm-assumption-testing
Plan how to test the assumptions behind a product idea before building — decompose the idea into its load-bearing beliefs, prioritize the riskiest, phrase them as falsifiable hypotheses, and pick the cheapest method that answers the question. Or critique an existing validation… - 85identify-assumptions-new
Identify risky assumptions for a new product idea across 8 risk categories including Go-to-Market, Strategy, and Team. Use when evaluating startup risks, assessing a new product concept, or mapping assumptions for a new venture. - 90identify-risky-assumptions
Lists and rates the risky assumptions behind a product idea or feature: 8 risk categories for a new venture, or the 4 core risks for a feature, each with confidence and a test. Use when the user asks for the riskiest assumptions, an assumption map or risk assessment, devil's… - 100assumptions-and-objections
Surface the load-bearing assumptions in a captured idea and the most likely objections an investor, customer, or skeptical advisor would raise. Produces an assumption-validation plan and an objection-handling brief. Use when the user wants to pressure-test an idea before committing time or capital.