How to Run a Pre-Mortem Risk Analysis for a PRD or Launch Plan

Use the /pre-mortem command in the phuryn/pm-skills repository to simulate a failed launch, identify risks across technical and business dimensions, and generate a structured markdown report categorizing threats as Tigers, Paper Tigers, or Elephants with specific mitigation plans.

Running a pre-mortem risk analysis for a PRD or launch plan allows product teams to surface hidden threats before they materialize. The phuryn/pm-skills open-source framework provides a declarative, markdown-driven skill that walks you through imagining a failed launch and working backwards to identify specific risks. This approach transforms risk management from reactive firefighting into a structured, forward-looking exercise that integrates directly into your product development workflow.

What Is a Pre-Mortem Risk Analysis?

A pre-mortem is a structured, forward-looking risk-identification exercise where you imagine a launch has already failed and work backwards to surface hidden problems. According to the phuryn/pm-skills source code, the framework classifies every identified risk into three distinct buckets:

• Tigers: Real, substantive risks that could derail the launch
• Paper Tigers: Over-blown concerns that are unlikely to materialize
• Elephants: Unspoken or hidden worries that the team avoids discussing

Each Tiger receives further classification by urgency. The system ranks them as launch-blocking, fast-follow, or track, ensuring you know exactly which mitigations must be addressed before go-live versus which can be monitored post-launch.

How the Pre-Mortem Framework Works

The implementation in pm-execution/skills/pre-mortem/SKILL.md follows a five-step architectural flow:

1. Input ingestion – The command accepts any description of a PRD, launch plan, or feature spec via plain text, markdown, or uploaded files.

2. Risk identification – The skill runs a step-by-step imagination of a failed launch, generating risk statements across technical, user, business, operational, and dependency dimensions.

3. Classification – Each risk is automatically categorized as Tiger, Paper Tiger, or Elephant. Tigers undergo further evaluation for severity.

4. Report generation – The system produces a structured markdown report with dedicated tables for launch-blocking Tigers, fast-follow Tigers, track Tigers, Paper Tigers, and Elephants.

5. Actionable output – The report includes mitigation suggestions, assigned owners, due dates, and concludes with a Go/No-Go checklist.

Because the skill and command are pure markdown-driven with no external service calls, the analysis remains fully reproducible and auditable.

When to Run a Pre-Mortem Analysis

Timing matters for maximum impact. According to the framework documentation, execute a pre-mortem risk analysis during these critical windows:

• Before a PRD is finalized – Early enough to reshape scope, yet late enough to have concrete assumptions to test against.

• During launch planning – When the product is approximately 80% ready, providing sufficient context for meaningful risk discovery.

• During sprint retrospectives – To re-evaluate risks that surfaced after a release and feed insights back into the next development cycle.

Step-by-Step Implementation Guide

Follow this workflow to run a pre-mortem risk analysis for your next PRD or launch plan:

1. Invoke the command using Claude Code, Claude Cowork, or any compatible UI that supports the phuryn/pm-skills commands.

2. Paste or upload your PRD, launch plan, or feature specification document.

3. Answer follow-up prompts if the skill requests clarification on ambiguous sections of your documentation.

4. Review the generated markdown report, which saves automatically as PreMortem-<product-name>-<date>.md.

5. Act on the recommendations by assigning owners, scheduling mitigations, and updating the PRD to reflect newly identified constraints.

Practical Examples and Command Usage

Invoking the /pre-mortem Command

To trigger the analysis from a Claude chat interface, use the slash command followed by your PRD description:

/pre-mortem
We're launching a self-serve billing portal next month. The PRD includes a checkout flow, subscription management, and email receipts.

The assistant processes this input through the risk identification pipeline and returns a structured report:

## Pre-Mortem: Billing Portal

### Tigers (Real Risks)

| # | Risk | Likelihood | Impact | Mitigation | Owner | Deadline |

|---|------|-----------|--------|-----------|-------|----------|
| 1 | Payment gateway latency > 2s | High | Critical | Add retry logic + alerting | Eng Lead | 2026-07-01 |
| … | … | … | … | … | … | … |

### Paper Tigers

- "Customers will dislike UI" – mitigated by A/B testing with early beta users.

### Elephants in the Room

- "The finance team has not approved the new pricing model" – schedule a joint review.

### Go/No-Go Checklist

- [ ] All launch-blocking Tigers mitigated
- [ ] Fallback payment processor configured
- [ ] Legal review completed for receipts

Advanced Skill Invocation

For advanced prompting scenarios where you need direct access to the underlying skill without the command wrapper, use the skill identifier:

pre-mortem
Run a pre-mortem risk analysis on the attached PRD for the new analytics dashboard.

This invocation bypasses the conversational command layer while producing the same structured markdown output.

Saving and Versioning Reports

The command automatically instructs the assistant to persist the analysis. Specify the filename explicitly to ensure proper versioning:

Save as `PreMortem-AnalyticsDashboard-2026-06-14.md`

Store this file alongside your PRD in version control to maintain an auditable trail of risk assumptions and mitigation status.

Understanding the Source Implementation

The phuryn/pm-skills repository uses a declarative, markdown-first architecture. These key files define the pre-mortem workflow:

File	Purpose
pm-execution/skills/pre-mortem/SKILL.md	Full skill definition including risk categories, classification logic, and output templates
pm-execution/commands/pre-mortem.md	Command specification that wires the skill into conversational workflows, including invocation syntax
README.md	Top-level overview of the marketplace structure and command organization
pm-execution/skills/create-prd/SKILL.md	Optional reference showing how PRD creation precedes risk analysis

Examining pm-execution/skills/pre-mortem/SKILL.md reveals the exact prompts used to generate each risk bucket, while pm-execution/commands/pre-mortem.md demonstrates how the system captures user input and triggers the skill execution.

Summary

• Pre-mortems prevent failure by imagining a failed launch and working backwards to identify risks before they materialize.
• Three risk categories classify threats as Tigers (real), Paper Tigers (over-blown), or Elephants (unspoken).
• Severity ranking separates launch-blocking issues from fast-follow and track items.
• Pure markdown implementation in phuryn/pm-skills ensures reproducible, auditable analysis without external dependencies.
• Command and skill interfaces provide both conversational (/pre-mortem) and direct (pre-mortem) invocation methods.
• Structured output generates PreMortem-<product>-<date>.md files with mitigation tables and Go/No-Go checklists.

Frequently Asked Questions

What is the difference between Tigers, Paper Tigers, and Elephants?

Tigers represent real, substantive risks that could actually derail your launch if not addressed. Paper Tigers are concerns that sound threatening but are unlikely to materialize or have minimal impact. Elephants are the dangers nobody wants to talk about—unspoken assumptions or hidden worries that the team avoids discussing but could catastrophically undermine the project if ignored.

How does the pre-mortem command handle different document formats?

The command accepts input through input ingestion that processes plain text, markdown content, or uploaded files. According to pm-execution/commands/pre-mortem.md, the skill parses PRDs, launch plans, or feature specifications regardless of format, then generates the standardized risk classification report.

Can I customize the risk categories or severity levels?

The current implementation in pm-execution/skills/pre-mortem/SKILL.md uses the fixed three-bucket taxonomy (Tigers, Paper Tigers, Elephants) and three-tier severity ranking (launch-blocking, fast-follow, track). Because the framework is open-source and markdown-driven, you can fork the repository and modify the skill definition to add custom categories or severity levels that match your organization's risk taxonomy.

When should I run a pre-mortem versus a post-mortem?

Run a pre-mortem before launch to identify risks while you still have time to mitigate them—ideally when your PRD is 80% complete or during final launch planning. Run a post-mortem after launch to analyze what actually went wrong. The phuryn/pm-skills framework supports both, but the pre-mortem skill specifically targets proactive risk identification rather than reactive incident analysis.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}