Pre-Mortem Skills: Stress-Testing Product Roadmaps With AI Before You Build
A pre mortem skill product roadmap ai workflow is the highest-ROI thing a PM can run this quarter, and almost nobody does it. The exercise: imagine your product launched and failed, then work backwards to figure out why. Done well, it surfaces the three or four risks that would've sunk you and lets you redesign around them in week zero. Run by humans, it eats an afternoon. Run through an AI skill, it takes 20 minutes and produces a ranked, mitigation-tagged failure-mode table. After running about a dozen of these against real roadmaps over the last six months, here's the workflow that sticks, with a worked example you can copy.
Why pre-mortems get skipped (and why that's expensive)
Gary Klein popularised the pre-mortem in 2007 and every product book since has parroted it. The technique is famous. The practice is rare. I've worked with seven product teams in the last two years and exactly one ran a pre-mortem before a major launch. Everyone agreed they should. Nobody did.
The reason is logistics, not laziness. A real pre-mortem needs four to eight people in a room for two hours, a facilitator who can keep things from devolving into either groupthink or sniping, structured prompting, and a write-up afterwards. The cost is real and the payoff is invisible — you're paying upfront to avoid a failure that, if you do it well, never shows up. Quarterly planning crunches always win that trade.
What's changed in 2026 is that the structured-thinking part is now something you can offload to a skill. The room of people was always proxying for "diverse perspectives applied rigorously." A well-built pre-mortem skill does that part in 20 minutes, and the human team only has to show up for decisions. That's the unlock.
The 20-minute AI pre-mortem, step by step
Here's the loop I run before any roadmap commit larger than a single sprint. Five steps, roughly four minutes each.
Step 1: Feed the roadmap in raw
Don't pre-clean it. Drop the actual roadmap doc, the PRD, the rough Notion page, the Linear epic — whatever your team actually wrote. Skills get more signal from messy artifacts than tidy summaries. If your roadmap doesn't exist in writing yet, that's your first pre-mortem finding right there.
Step 2: Set the failure frame
Tell the skill: "It's 12 months from now. This product launched and failed. Write the post-mortem." The framing matters. "What could go wrong" produces a vague worry list. "It already failed, explain why" produces specific, causal, ranked failure stories. The pre-mortem trick is half its own power.
Step 3: Get raw failure modes
The skill returns 15–25 distinct failure modes spanning market, technical, organisational, financial, and adoption categories. Resist the urge to filter yet. Some will look implausible. A few of those will be the ones you should worry about most.
Step 4: Score them — likelihood × impact
For each failure mode, score probability (1–5) and severity (1–5). The skill does first-pass scoring; you adjust based on what you know about your team and market. Multiply for a 1–25 risk score. Anything above 12 gets attention. Anything above 16 forces a roadmap change.
Step 5: Decide what to redesign
The point of a pre-mortem isn't a document, it's a decision. For each high-score failure mode, the team picks one of four responses: redesign to remove the risk, build a mitigation, accept it explicitly, or cancel the bet. Most failure modes get "accept" — that's fine, the value is making the choice consciously.
Worked example: an AI invoice automation tool
Concrete is better than abstract. Let me walk through a real-shaped pre-mortem on a fake-but-plausible product. The product: an AI tool that ingests invoices from email, extracts line items, matches them to PO numbers, and posts approved invoices to QuickBooks. Buyer: SMB finance leads at companies with 10–50 employees. Pricing: $79/month per seat. Launch: 90 days out.
I fed the (deliberately rough) roadmap to a pre-mortem skill with the failure frame. Twenty minutes later, here's what came back. Two things to note before the table. The skill grouped failures by category — market, technical, GTM, ops — which makes the meeting afterwards easier because each owner sees their own column. And several of the highest-scoring risks were ones the founding team had explicitly dismissed in the original PRD. That's the pattern I see most often. The pre-mortem doesn't surface unknowns, it forces re-examination of things you'd already decided to ignore.
The failure-modes table, ranked by likelihood × impact
Top eight failure modes for the AI invoice automation tool, post-AI scoring, post-human-adjustment:
| # | Failure mode | Category | Prob (1-5) | Sev (1-5) | Score | Mitigation |
|---|---|---|---|---|---|---|
| 1 | QuickBooks API rate limits throttle real-time posting at scale; customers see "stuck" invoices | Technical | 5 | 4 | 20 | Build a queue + retry layer in v1, not v2; surface queue status in UI from day one |
| 2 | SMB finance leads won't trust AI extraction without a human-in-the-loop step, killing the "automation" pitch | Market | 5 | 4 | 20 | Reframe as "AI-assisted" not "automated"; ship a confidence-score UI so users approve in bulk, not one-by-one |
| 3 | OCR + extraction accuracy on scanned PDF invoices below 95% means more cleanup work, not less | Technical | 4 | 5 | 20 | Set explicit accuracy SLA per invoice type; refuse handwritten/scanned categories at MVP |
| 4 | $79/seat is below the threshold where SMB finance leads can expense without approval — sales cycle stalls | GTM | 4 | 4 | 16 | Either drop to $49 (impulse purchase) or jump to $149 with an annual contract; $79 is the dead zone |
| 5 | Existing tools (Bill.com, Ramp) bundle invoice automation; standalone product can't compete on price | Market | 4 | 4 | 16 | Position as "invoice triage layer" that sits in front of existing AP tools; don't try to replace them |
| 6 | SOC 2 not in place at launch; mid-market deals stall in procurement | Ops | 4 | 3 | 12 | Start SOC 2 Type 1 process in week 1 (3-month timeline); publish Type 1 attestation at launch |
| 7 | Email ingestion via shared inbox creates a permissions nightmare for finance teams | Technical | 3 | 4 | 12 | Ship per-vendor forwarding addresses + Gmail/Outlook OAuth as first-class options |
| 8 | "AI" in the name triggers procurement review at any company over 50 employees | GTM | 3 | 3 | 9 | Test the brand without "AI" in the name; lead with "invoice triage" instead |
Three things jump out from the scores. The top three risks all hit 20 — meaning even a generous reading puts them at "we will fail in this exact way unless we do something." All three were dismissed or hand-waved in the original PRD. The mitigations are concrete and cheap; they cost a few weeks of v1 scope, not a strategy reset. And risks 4 and 5 together imply a pricing and positioning rethink, not a product rethink — which is great news, because pricing is cheaper to change than code.
Deliverable from the meeting after the AI pre-mortem: drop the auto-post claim, add a confidence-scored approval UI, reposition as a triage layer in front of existing AP tools, and move pricing to $49 or $149. Roadmap shifted by about three sprints. Probably saved the launch.
The three skills that make a pre-mortem product roadmap AI workflow real
The 20-minute version above is a composite of three skills working together. None of them is fancy on its own; the combination is what produces the table.
1. pre-mortem — the failure-frame engine
What it does: takes a roadmap, PRD, or pitch deck and returns 15–25 ranked failure modes from the future-failure perspective. Includes the prob × severity scoring rubric and the four-response decision framework (redesign, mitigate, accept, cancel).
Why PMs need it: it removes the facilitation burden. You don't have to coach a room of engineers through "imagine it failed" — the skill handles that and produces a structured artifact your team can argue over instead of generate from scratch.
The first time I ran this on a real roadmap, it surfaced a regulatory risk the legal team had flagged six months earlier and product had quietly forgotten about. The skill didn't know about the legal flag — it derived the risk from first principles. That's the moment I stopped treating pre-mortems as optional.
2. sun-tzu-business-strategy — the competitive frame
What it does: applies classical strategic principles — terrain, positioning, force concentration, knowing when not to fight — to product and GTM decisions. Sounds gimmicky. Isn't. The skill forces you to articulate what you're competing on and where you'd lose.
Why PMs need it: half of pre-mortem failure modes are competitive ("Bill.com bundles this for free"). A pure technical pre-mortem misses them. Running the roadmap through this skill after pre-mortem catches the strategic-positioning failures the failure-frame alone won't surface.
Pair it with churn-to-cashflow agent skills for the financial side of the same picture — together they cover most "why our market position erodes" risks.
Install sun-tzu-business-strategy →
3. lss-artifacts — the operational rigor layer
What it does: generates Lean Six Sigma-style artifacts — fishbone diagrams, FMEA tables, control charts — from rough product specs. The FMEA overlap with pre-mortem is direct: lss-artifacts produces the formal version of what pre-mortem produces conversationally.
Why PMs need it: if you ship into regulated industries — finance, health, anything with auditors — the pre-mortem table needs to become a formal FMEA artifact. lss-artifacts does that conversion. You go from "we thought about it" to a documented failure-modes analysis with assigned mitigations — which is what regulators and enterprise procurement want to see.
For solo founders shipping at MVP speed, this is overkill on day one. Keep it in mind for the first enterprise deal.
What pre-mortems won't fix
Three honest limitations after running a lot of these.
- They don't beat conviction-driven founders. If the founder is committed to the original plan, an AI pre-mortem won't change their mind. It'll produce a document they ignore. Pre-mortems work when the team genuinely wants to find risks.
- They surface risks, not solutions. The mitigation column is a starting point, not a plan. Each accepted risk still needs an owner and a date. Without that, you've made a list and called it work.
- They miss black swans. Pre-mortems extrapolate from known categories. A truly novel risk — your model provider deprecating an API, a competitor open-sourcing your moat — usually doesn't show up. Combine with a separate live-incident war-room workflow for unknowns you'll have to handle in real time.
Run the pre-mortem anyway. The 80% it catches beats the 20% it misses.
FAQ
What's a pre mortem skill product roadmap ai workflow good for, exactly?
It's good for any commitment larger than a single sprint where redesigning later is more expensive than redesigning now. New product launches, major architectural pivots, big GTM bets, hiring plans tied to revenue assumptions. Not worth 20 minutes for a small feature flag rollout.
Should I run this with or without my team in the room?
Run the skill alone first to get the failure-modes table, then bring the team in to score and decide. Doing it as a group from scratch wastes the skill's main advantage (speed) and reintroduces the meeting tax that made you skip pre-mortems in the first place.
How often should I re-run a pre-mortem on the same roadmap?
Once at planning, once at the halfway point of a quarter, and once before launch. Risks that scored low in week one often climb the ranks as the build proceeds. The mid-quarter re-run is the one most teams skip and most often regret.
Can I use this for engineering decisions, not just product roadmaps?
Yes. The same loop works on architectural decisions, vendor choices, and migration plans. For weekend-MVP scope decisions specifically, the techniques in ship MVPs in a weekend are more proportionate.
Does this work for B2C products too?
Yes, with an adjustment. B2C failure modes skew toward distribution, retention, and unit economics rather than the technical and procurement risks that dominate B2B pre-mortems. The skill picks that up if you tell it the buyer category in step 1; if you don't, it'll over-index on enterprise-shaped risks.
The bottom line
Pre-mortems work. They've always worked. The reason your team doesn't run them isn't disbelief — it's that the human version costs an afternoon and the AI version costs 20 minutes. Run one before your next quarterly commit. If the table doesn't surface at least one risk that changes your roadmap, you can stop. If it does — and it will, the first three or four times — you've just bought yourself the kind of clarity that used to require a much more painful process.
Single starting point: install pre-mortem, point it at the roadmap you were going to ship anyway, and see what falls out. The other two skills compound from there.
→ Browse all product skills · Request a skill that doesn't exist yet
