justin/pm-skills
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release v2.0.0: add pm-ai-shipping plugin, red-team execution skill, refresh README

Browse Source 
New
- pm-ai-shipping (9th plugin) — AI Shipping Kit: document a vibe-coded app, audit
  security/performance against intended behavior, map test coverage, and compile a
  reviewer-ready shipping packet (2 skills, 5 commands).
- pm-execution: strategy-red-team skill + /red-team-prd command (now 16 skills, 11 commands).

Changed
- Bump all versions 1.0.1 -> 2.0.0 (marketplace.json + all 9 plugin.json) in lockstep.
- README: new plugins.png hero + examples.png in "How It Works"; counts updated to
  9 plugins / 68 skills / 42 commands across tagline, install block, and per-plugin sections.
- CLAUDE.md: 9-plugin structure, plugin table, and version note updated.

Validator: 9 plugins, 68 skills, 42 commands, 110 components, 0 warnings.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Pawel Huryn
2026-06-05 18:49:54 +02:00
parent 2b4e4dc151
commit 8202bdd7f1
25 changed files with 782 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pm-execution/.claude-plugin/plugin.json
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "pm-execution",
"version": "1.0.1",
"version": "2.0.0",
"description": "Execution and product management skills: PRDs, OKRs, roadmaps, sprints, pre-mortems, stakeholder maps, user stories, prioritization frameworks, and more.",
"author": {
"name": "Paweł Huryn",
pm-execution/README.md
+4 -2
View File
@@ -2,7 +2,7 @@
Execution and product management skills: PRDs, OKRs, roadmaps, sprints, pre-mortems, stakeholder maps, user stories, prioritization frameworks, and more.
## Skills (15)
## Skills (16)
- **brainstorm-okrs** — Brainstorm team-level OKRs aligned with company objectives.
- **create-prd** — Create a Product Requirements Document using a comprehensive 8-section template covering summary, background, objectives, market segments, value propositions, solution details, and release planning.
@@ -15,17 +15,19 @@ Execution and product management skills: PRDs, OKRs, roadmaps, sprints, pre-mort
- **retro** — Facilitate a structured sprint retrospective.
- **sprint-plan** — Plan a sprint with capacity estimation, story selection, dependency mapping, and risk identification.
- **stakeholder-map** — Build a stakeholder map using a power/interest grid, identify communication strategies per quadrant, and generate a communication plan.
- **strategy-red-team** — Red-team a PRD, roadmap, or strategy by attacking its load-bearing assumptions; rank failure modes and return the cheapest test and kill criteria for each.
- **summarize-meeting** — Summarize a meeting transcript into a structured template with date, participants, topic, summary points, and action items.
- **test-scenarios** — Create comprehensive test scenarios from user stories with test objectives, starting conditions, user roles, step-by-step actions, and expected outcomes.
- **user-stories** — Create user stories following the 3 C's (Card, Conversation, Confirmation) and INVEST criteria with descriptions, design links, and acceptance criteria.
- **wwas** — Create product backlog items in Why-What-Acceptance format.
## Commands (10)
## Commands (11)
- `/pm-execution:generate-data` — Generate realistic dummy datasets for testing — CSV, JSON, SQL inserts, or Python scripts.
- `/pm-execution:meeting-notes` — Summarize a meeting transcript into structured notes with decisions, action items, and follow-ups.
- `/pm-execution:plan-okrs` — Brainstorm team-level OKRs aligned with company objectives — qualitative objectives with measurable key results.
- `/pm-execution:pre-mortem` — Run a pre-mortem risk analysis on a PRD, launch plan, or feature — identify what could go wrong before it does.
- `/pm-execution:red-team-prd` — Red-team a PRD, roadmap, or strategy — attack its load-bearing assumptions and return the cheapest test for each before you commit.
- `/pm-execution:sprint` — Sprint lifecycle — plan a sprint, run a retrospective, or generate release notes.
- `/pm-execution:stakeholder-map` — Map stakeholders on a Power × Interest grid and create a tailored communication plan.
- `/pm-execution:test-scenarios` — Generate comprehensive test scenarios from user stories or feature specs — happy paths, edge cases, and error handling.
pm-execution/commands/red-team-prd.md
+66
View File
@@ -0,0 +1,66 @@
---
description: Red-team a PRD, roadmap, or strategy — attack its load-bearing assumptions and return the cheapest test for each before you commit
argument-hint: "<PRD, roadmap, strategy, or the current doc>"
---
# /red-team-prd -- Attack the Plan Before Reality Does
Most plans only survived polite feedback. This command finds the assumptions that would make yours fail, attacks them honestly, and hands you the cheapest test for each — so you can kill a bad bet this week instead of at launch.
## Invocation
```
/red-team-prd [paste or upload a PRD, roadmap, or strategy]
/red-team-prd Prioritize AI onboarding — activation is our bottleneck
/red-team-prd the current doc
```
## Workflow
### Step 1: Accept the Plan
Take it in any form — PRD, roadmap, strategy memo, one-line bet, or an uploaded doc. If the user says "the current doc," use the document in context.
### Step 2: Red-Team It
Apply the **strategy-red-team** skill:
- Extract every claim; keep only the **load-bearing** ones (false → plan dies).
- **Steelman each, then attack the steelman** — no strawmen.
- Write each failure mode as "**Fails if ___**."
- Rank by **(impact if wrong) × (likelihood wrong) × (cheapness to test)**.
- Default "the risk is real" unless the plan cites evidence against it — but **say plainly what's well-reasoned**, and never fabricate a weakness.
### Step 3: Return the Output
```
## Red-Team: [plan in one line]
### Top Kill-Assumptions (ranked)
- **Claim:** [load-bearing assertion]
- **Fails if:** [concrete, falsifiable]
- **Evidence to get this week:** [specific]
- **Kill criterion:** [threshold]
- **Cheapest test:** [smallest experiment]
[3–5 max]
### What's Well-Reasoned
[State it explicitly — don't manufacture doubt.]
### What I Couldn't Assess
[Where the plan didn't give enough to judge.]
```
### Step 4: Offer Next Steps
- "Want me to **turn the top kill-assumption into an experiment** you can run this week?"
- "Should I **run a pre-mortem** to complement this — imagine it already failed and trace the path?"
- "Want me to **rewrite the riskiest section** of the plan to address what survived?"
## Notes
- Lead with the ranking — the cheapest high-impact test is the whole point.
- Five real kill-assumptions with tests beat twenty generic risks. Cut ruthlessly.
- Distinct from `/pre-mortem`: pre-mortem narrates failure after the fact; red-team attacks the live assumptions and hands you the test.
- If the plan is genuinely strong, the most valuable output is saying so — and naming the one thing still worth checking.
- For a second-opinion pass, ask the user before adding cross-model friction; different model families miss different things, but most plans don't need it.
pm-execution/skills/strategy-red-team/SKILL.md
+72
View File
@@ -0,0 +1,72 @@
---
name: strategy-red-team
description: "Red-team a PRD, roadmap, or strategy by attacking its load-bearing assumptions before reality does. Steelmans then attacks each claim, ranks failure modes by impact × likelihood × cheapness-to-test, and returns the cheapest test and kill criteria for each. Use when stress-testing a plan, pressure-testing a strategy, challenging assumptions, or preparing a doc for executive review."
---
# Strategy Red-Team: Attack the Assumptions Before Reality Does
## Purpose
You are a sharp, fair adversary reviewing $ARGUMENTS. Most plans only survived polite feedback. This skill finds the load-bearing assumptions that would make the plan fail, attacks them honestly, and returns — for each — the evidence to get this week, the kill criteria, and the cheapest test.
## Context
A red-team is not a pre-mortem. A pre-mortem imagines the plan already failed and narrates why. A red-team attacks the load-bearing assumptions and logic **now**, while there's still time to test the cheapest one. It improves judgment, not just confidence.
The goal is a sharper decision, not a longer risk list. Five real kill-assumptions with tests beat twenty generic risks.
## Instructions
1. **Extract every claim.** Read the plan and list what it asserts as true — about the user, the market, the constraint, the mechanism, the timeline. Separate **load-bearing** claims (if false, the plan dies) from cosmetic ones. Only load-bearing claims are worth attacking.
2. **Steelman, then attack.** For each load-bearing claim, first state the strongest version of why it might be true. Then attack *that* — not a strawman. An attack on a weak version of the claim is worthless.
3. **Write each failure mode as "Fails if ___."** Be concrete and falsifiable. "Fails if activation isn't actually the constraint" beats "execution risk."
4. **Rank by (impact if wrong) × (likelihood wrong) × (cheapness to test).** The top of the list is what to test *this week* — high-impact, plausibly wrong, and cheap to check. Surface that ranking; don't bury the lede.
5. **Self-refute, don't fabricate.** Default to "this risk is real" unless the plan already cites evidence against it. But if a claim is genuinely well-reasoned, say so plainly — a red-team that manufactures doubt is as useless as one that rubber-stamps. Never invent a weakness the plan doesn't have.
6. **For each surviving kill-assumption, give the operator something to do:**
- **Fails if:** the precise condition that breaks the plan
- **Evidence to get this week:** the specific data, query, or conversation that would confirm or kill it cheaply
- **Kill criterion:** the threshold at which you'd stop or change course
- **Cheapest test:** the smallest experiment that moves the belief
7. **Optional cross-model mode.** If the user asks for a second opinion and another model (Codex, Gemini, a second Claude) is reachable, run the same plan through it and flag where the two disagree — different model families miss different things. Default is single-model; don't add this friction unless asked.
8. **Structure the output (make it screenshot-native):**
```
## Red-Team: [plan in one line]
### Top Kill-Assumptions (ranked)
For each (3–5 max):
- **Claim:** [the load-bearing assertion]
- **Fails if:** [concrete, falsifiable condition]
- **Evidence to get this week:** [specific]
- **Kill criterion:** [threshold]
- **Cheapest test:** [smallest experiment]
### What's Well-Reasoned
[State explicitly what holds up — and why. Don't manufacture doubt.]
### What I Couldn't Assess
[Gaps where the plan didn't give enough to judge.]
```
## Notes
- No strawmanning — attack the steelman or don't attack.
- No generic risk lists — every item must be specific to *this* plan.
- No fabrication — if it's sound, say so.
- Rank ruthlessly — the cheapest high-impact test is the whole point.
- The emotional job is relief from the fear of confidently shipping the wrong bet, so end with what to *do*, not just what to fear.
---
### Further Reading
- [Assumption Prioritization Canvas: How to Identify And Test The Right Assumptions](https://www.productcompass.pm/p/assumption-prioritization-canvas)
- [How to Manage Risks as a Product Manager](https://www.productcompass.pm/p/how-to-manage-risks-as-a-product-manager)
- [How Meta and Instagram Use Pre-Mortems to Avoid Post-Mortems](https://www.productcompass.pm/p/how-to-run-pre-mortem-template)