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

> Run a pre-mortem risk analysis for your PRD or launch plan using the phuryn/pm-skills repository. Identify and categorize risks to generate actionable mitigation strategies.

- Repository: [Pawel Huryn/pm-skills](https://github.com/phuryn/pm-skills)
- Tags: how-to-guide
- Published: 2026-06-13

---

**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`](https://github.com/phuryn/pm-skills/blob/main/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:

```text
/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:

```markdown

## 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:

```text
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:

```text
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`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/pre-mortem/SKILL.md) | Full skill definition including risk categories, classification logic, and output templates |
| [`pm-execution/commands/pre-mortem.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/commands/pre-mortem.md) | Command specification that wires the skill into conversational workflows, including invocation syntax |
| [`README.md`](https://github.com/phuryn/pm-skills/blob/main/README.md) | Top-level overview of the marketplace structure and command organization |
| [`pm-execution/skills/create-prd/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/create-prd/SKILL.md) | Optional reference showing how PRD creation precedes risk analysis |

Examining [`pm-execution/skills/pre-mortem/SKILL.md`](https://github.com/phuryn/pm-skills/blob/main/pm-execution/skills/pre-mortem/SKILL.md) reveals the exact prompts used to generate each risk bucket, while [`pm-execution/commands/pre-mortem.md`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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`](https://github.com/phuryn/pm-skills/blob/main/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.