post-mortems-retrospectives
Run blameless post-mortems & retrospectives and produce a Post-mortems & Retrospectives Pack (brief + agenda, facts/timeline, contributing factors + root causes, decisions + action tracker, kill criteria, learning dissemination plan). Use for postmortem, post-mortem, retrospective, retro, after action review, lessons learned. Category: Leadership.
What this skill does
# Post-mortems & Retrospectives ## Scope **Covers** - Running **blameless** incident post-mortems and project/OKR retrospectives - Turning “what happened?” into **system learnings + decisions** (not blame) - Creating **follow-through**: owners, due dates, success signals, and review cadence - Adding **kill criteria / triggers** so future pre-mortems lead to real action - Institutionalizing learning via a lightweight “**Impact & Learnings**” review **When to use** - “Run a postmortem / retrospective for <incident/project> and write the doc.” - “We missed OKRs—lead a retro focused on learning and systemic blockers.” - “Create an after-action review with action items and owners.” - “Set up a weekly impact & learnings review so insights don’t die in docs.” - “Do a pre-mortem and define kill criteria / pivot triggers.” **When NOT to use** - The incident is **still active** (do incident response first; schedule the review after stabilization) - The goal is to **assign blame** or evaluate an individual’s performance (use HR/management processes) - You need deep technical debugging without the right experts (this skill facilitates; it doesn’t replace engineering investigation) - You need to decide *what problem to solve* (use a problem-definition / discovery process first) ## Inputs **Minimum required** - What are we reviewing? (incident / project / OKR period) + 1–2 sentence summary - Time window and key dates (start/end; detection time; resolution time if incident) - Desired outcome (learning, prevention, speed, quality, alignment) - Participants/roles (facilitator, scribe, decision owner; key stakeholders) - Evidence available (timeline notes, metrics, dashboards, tickets, docs) - Constraints (privacy; what to anonymize; audience) **Missing-info strategy** - Ask up to 5 questions from [references/INTAKE.md](references/INTAKE.md) (3–5 at a time). - If details are unavailable, proceed with explicit assumptions and label unknowns. - Do not request secrets or personal data; use anonymized descriptions. ## Outputs (deliverables) Produce a **Post-mortems & Retrospectives Pack** in Markdown (in-chat; or as files if requested): 1) **Retro brief + agenda** (purpose, attendees, roles, pre-reads, ground rules) 2) **Facts + timeline** (what happened; impact; timestamps; links) 3) **Contributing factors + root cause hypotheses** (systems lens; “why it made sense”) 4) **Learnings + decisions** (what changes; why; tradeoffs) 5) **Action tracker** (owner, due date, success signal, follow-up date) 6) **Kill criteria / triggers** (signals → committed action) for future work 7) **Learning dissemination plan** (how to socialize + a recurring “Impact & Learnings” review) 8) **Risks / Open questions / Next steps** (always) Templates: [references/TEMPLATES.md](references/TEMPLATES.md) Expanded guidance: [references/WORKFLOW.md](references/WORKFLOW.md) ## Workflow (7 steps) ### 1) Classify the review + set blameless ground rules - **Inputs:** request context; [references/INTAKE.md](references/INTAKE.md). - **Actions:** Identify the review type (incident / project / OKR). Set a blameless norm (“fix systems, not people”) and decide whether to reframe language as “retrospective” to signal learning. Confirm facilitator, scribe, and decision owner. - **Outputs:** Retro brief (draft) + attendee list + meeting invite outline. - **Checks:** Objective is explicit (learning + improvement). Roles are assigned. ### 2) Assemble facts and a shared timeline (separate facts from stories) - **Inputs:** artifacts (tickets, dashboards, logs, notes). - **Actions:** Build a timestamped timeline; quantify impact; list “known facts” vs “assumptions to verify”. - **Outputs:** Facts + timeline section using [references/TEMPLATES.md](references/TEMPLATES.md). - **Checks:** Timeline has timestamps and links/evidence where possible. Assumptions are labeled. ### 3) Diagnose contributing factors (systems lens) - **Inputs:** timeline + impact. - **Actions:** Cluster causes across People / Process / Product / Tech / Comms / Environment. Use a “make it reasonable” lens: what conditions made the outcome likely? Optionally run 5 Whys on the top 1–2 factors. - **Outputs:** Contributing factors map + root cause hypotheses. - **Checks:** Avoids individual blame language; identifies system conditions that can be changed. ### 4) Extract learnings and decide what to change - **Inputs:** contributing factors. - **Actions:** Write 3–7 crisp learnings (“we learned that…”). Convert learnings into decisions (fix, guardrail, instrumentation, runbook, training, scope change). Keep OKR/grade discussion secondary to “why” and “what changes next”. - **Outputs:** Learnings + decisions section. - **Checks:** Each learning is tied to evidence and produces a concrete decision or experiment. ### 5) Build the action tracker (owners + dates + success signals) - **Inputs:** decisions. - **Actions:** Create action items with an owner, due date, and success signal. Add a follow-up review date (or a recurring review). Limit to what can realistically be executed; explicitly park “later ideas”. - **Outputs:** Action tracker table + follow-up plan. - **Checks:** No orphan actions: every item has owner + date. Top actions address top factors. ### 6) Add kill criteria / triggers (pre-commit to future action) - **Inputs:** learnings; “what would we do differently next time?” - **Actions:** Define 3–10 signals that indicate failure modes or lack of traction. For each signal, pre-commit to an action (pause, pivot, kill, escalate, add investment). - **Outputs:** Kill criteria / trigger list. - **Checks:** Each criterion is observable/measurable and has a committed action (not “discuss it”). ### 7) Disseminate learning + quality gate + finalize - **Inputs:** full draft pack. - **Actions:** Create a 1-page shareout (TL;DR, top actions, decisions). Propose a lightweight weekly/biweekly “Impact & Learnings” review to socialize learnings beyond the team. Run [references/CHECKLISTS.md](references/CHECKLISTS.md) and score with [references/RUBRIC.md](references/RUBRIC.md). Add **Risks / Open questions / Next steps**. - **Outputs:** Final Post-mortems & Retrospectives Pack. - **Checks:** Shareout is understandable by the intended audience; follow-through mechanism exists; rubric passes. ## Quality gate (required) - Use [references/CHECKLISTS.md](references/CHECKLISTS.md) and [references/RUBRIC.md](references/RUBRIC.md). - Always include: **Risks**, **Open questions**, **Next steps**. ## Examples **Example 1 (incident postmortem):** “We had a 45-minute outage in our payments API yesterday. Run a blameless postmortem and output the full Pack (timeline, contributing factors, action tracker, and a shareout).” Expected: evidence-backed timeline, systems causes, owned actions, dissemination plan. **Example 2 (OKR retro):** “We hit 0.8 on our Q4 activation OKR. Lead a retrospective focused on why (systemic blockers) and what we change next quarter. Output the full Pack and kill criteria for the next initiative.” Expected: learnings > grade, decisions, owned actions, triggers for early course correction. **Boundary example:** “Write a postmortem proving that Person X caused the incident.” Response: refuse blame framing; redirect to systems-based review and, if needed, suggest a separate HR/management process for performance topics.
Related in Code Review
gstack
IncludedFast headless browser for QA testing and site dogfooding. Navigate pages, interact with elements, verify state, diff before/after, take annotated screenshots, test responsive layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)
startup-due-diligence
IncludedLegal due diligence review for seed-stage and Series A startups (US, Delaware C-Corp focus). Supports both investor and founder perspectives. Capabilities include: (1) Interactive document review and issue spotting; (2) Document request list generation; (3) Cap table and SAFE/convertible note analysis; (4) Red flag identification with severity ratings; (5) Diligence report generation. TRIGGERS: due diligence, DD, startup investment, cap table review, Series A, seed round, investor diligence, legal review startup, SAFE analysis, convertible note, 409A, founder vesting.
interview-master
IncludedThis skill should be used when the user asks to "generate interview questions", "prepare for interview", "optimize resume", "conduct mock interview", "analyze git commits for resume", "generate resume from code", "review my resume", or mentions interview preparation, career assistance, or extracting project experience from git history. Provides comprehensive interview and career development guidance for both job seekers and interviewers.
fix-issue
IncludedFixes GitHub issues using parallel analysis agents for root cause investigation, code exploration, and regression detection. Reads issue context from gh CLI, searches codebase and memory for related patterns, generates a fix with tests, and links the resolution back to the issue via PR. Includes prevention analysis to avoid recurrence. Use when debugging errors, resolving regressions, fixing bugs, or triaging issues.
sf-apex
IncludedGenerates and reviews Salesforce Apex code with 150-point scoring. TRIGGER when: user writes, reviews, or fixes Apex classes, triggers, test classes, batch/queueable/schedulable jobs, or touches .cls/.trigger files. DO NOT TRIGGER when: LWC JavaScript (use sf-lwc), Flow XML (use sf-flow), SOQL-only queries (use sf-soql), or non-Salesforce code.
swift-development
IncludedComprehensive Swift development for building, testing, and deploying iOS/macOS applications. Use when Claude needs to: (1) Build Swift packages or Xcode projects from command line, (2) Run tests with XCTest or Swift Testing framework, (3) Manage iOS simulators with simctl, (4) Handle code signing, provisioning profiles, and app distribution, (5) Format or lint Swift code with SwiftFormat/SwiftLint, (6) Work with Swift Package Manager (SPM), (7) Implement Swift 6 concurrency patterns (async/await, actors, Sendable), (8) Create SwiftUI views with MVVM architecture, (9) Set up Core Data or SwiftData persistence, or any other Swift/iOS/macOS development tasks.