Skip to main content
skill CX Codex

after-action-report — Claude Code skill: what it does, install

after-action-report runs a structured review of an incident, launch, or finished project, then turns the findings into causes, lessons, and owned actions.

MIT 292 installs ★ 1,107 updated 2026-10-19

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rampstackco/claude-skills --skill after-action-report -a claude-code
Open on GitHub

What after-action-report does

This skill reviews a past event such as an incident, product launch, or completed project. It organizes the result into a summary, event timeline, root-cause analysis, contributing factors, what worked, and action items with owners and due dates.

Its method is blameless: examine systems and the decisions people could reasonably make with the information available at the time. The required material includes the event itself, a timeline rebuilt from logs, chat, or tickets, participant accounts, and outcome data. Without a reconstructed timeline, the review has a weak factual base.

This is for retrospective analysis, not live incident handling or launch preparation. The description points those cases to incident-response and launch-runbook.

What it helps with

  • reconstruct an incident timeline
  • trace a failure to its root cause
  • separate causes from contributing factors
  • turn findings into owned action items

Example prompts for the agent

  • Review the resolved incident using the logs, chat history, and tickets.
  • Write a blameless postmortem for the launch and identify the root causes.
  • Run an after-action review for the completed project, including lessons and next actions.

How to install after-action-report

1Skills CLI (Vercel)

npx skills add rampstackco/claude-skills --skill after-action-report -a claude-code

2Manually: put the files in place

~/.claude/skills/after-action-report/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/after-action-report/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about after-action-report

How do I install after-action-report in Claude Code?

Run npx skills add rampstackco/claude-skills --skill after-action-report -a claude-code. The skill file will be at ~/.claude/skills/after-action-report/SKILL.md.

What does after-action-report do?

It reviews incidents, launches, and completed projects. The output covers the timeline, root causes, contributing factors, successful parts of the response, and concrete follow-up work.

What does after-action-report need to run a review?

Provide the event, a timeline rebuilt from logs, chat, or tickets, participant accounts, and outcome or impact data.

Source text

SKILL.md · MIT
---
name: after-action-report
description: "Run a structured after-action review (postmortem, retrospective) on a launch, incident, or completed project to capture timeline, root cause analysis, contributing factors, and actionable lessons. Use this skill whenever the user wants to run a postmortem, retrospective, AAR, or after-action review on any past event. Triggers on after-action report, AAR, postmortem, retrospective, retro, post-incident review, what went well what didn't, lessons learned, blameless postmortem, root cause analysis, RCA, five whys. Also triggers when the user has just shipped something or just resolved an incident and wants to capture learnings."
category: operations
catalog_summary: "Post-mortems, retros, learnings documentation"
display_order: 3
---

# After-Action Report

Run a structured retrospective on a launch, incident, or completed project. Produce actionable lessons, not just a document.

This skill is for after-the-fact analysis. For active incident response, use `incident-response`. For planning launches, use `launch-runbook`.

---

## When to use

- After any incident (any severity)
- After every major launch
- At the end of a project (sprint retro, quarterly retro, project closeout)
- When a recurring issue has happened enough times to demand investigation
- When a decision didn't work out and the team wants to learn

## When NOT to use

- During an active incident (use `incident-response`)
- For pre-launch planning (use `launch-runbook`)
- For one-off bug fixes that don't merit broad analysis

---

## Required inputs

- The event being analyzed (incident, launch, project)
- A timeline reconstructed from logs, chat, tickets
- Participant accounts of what they observed and did
- Outcomes and impact (what actually happened to users, the business)

---

## The framework: blameless analysis

The most important principle: blameless. Without it, retrospectives produce hidden information and theatrical lessons rather than real ones.

### What blameless means

- Focus on systems, not individuals
- Assume everyone made reasonable decisions given what they knew at the time
- The question is "why was this decision reasonable to make?" not "who screwed up?"
- Fixing the system means the next person in that situation succeeds where this person didn't

### What blameless does not mean

- No accountability (action items still have owners)
- No hard truths (sometimes the system is broken in obvious ways)
- No standards (some patterns of failure are individual, not systemic)
- No discomfort (real reflection is uncomfortable)

---

## The framework: 6 sections

A complete AAR covers six sections.

### 1. Summary

A 2 to 3 paragraph overview. Captures:

- What happened
- Impact (users, business, time)
- Root cause (in plain language)
- Top action items

This is what executives read. Anyone who reads only this section should leave with the most important information.

### 2. Timeline

A reconstructed timeline of events.

For incidents:
- T-0: Detection
- T+X: Acknowledgment
- T+Y: Severity assessed, IC assigned
- T+Z: Investigation began
- ... mitigation, communication, resolution events
- T+N: Resolution declared

For launches:
- Pre-launch decisions and milestones
- Launch day events
- Post-launch monitoring observations

For projects:
- Major milestones, decisions, pivots
- Both planned and emergent

The timeline is the source of truth. Disagreements about what happened get resolved here.

### 3. Root cause analysis

What caused this, in plain language.

Use one or both of:

**Five whys.** Start with the surface symptom. Ask "why?" Repeat 5 times (or until you reach a true root). Each "why" should yield a substantive answer, not a tautology.

Example:
- Why did the site go down? Database connection pool exhausted.
- Why was the pool exhausted? Background job opened too many connections.
- Why did the background job open too many connections? Connection cleanup code didn't run on errors.
- Why didn't cleanup run on errors? Original code review didn't cover error paths.
- Why didn't the review cover error paths? No checklist for error handling in our review process.

The fifth why often reveals the system fix. In this case: improve the review process.

**Causal chain.** Multiple contributing factors that combined.

- Factor 1: Background job opened too many connections (technical)
- Factor 2: Connection limit was set too low for actual traffic (configuration)
- Factor 3: No alert on connection pool saturation (monitoring)
- Factor 4: Recent traffic doubled without infra capacity review (process)

No single fix addresses the incident. Multiple gaps need attention.

### 4. Contributing factors

Factors that didn't cause the event but made it worse, or removed safety nets that would have caught it.

- Monitoring gaps
- Documentation gaps
- Process gaps
- Tooling gaps
- Knowledge gaps

A "would have been caught earlier if..." factor.

### 5. What went well

Real lessons require capturing successes, not just failures.

- What detection worked?
- What response worked?
- What decisions were good?
- What tools or processes performed as expected?

This is not consolation. It's calibration. Things that worked here should be reinforced and replicated.

### 6. Action items

Specific, owned, dated.

| Action | Owner | Due | Type |
|---|---|---|---|
| Add alert on connection pool saturation | [name] | [date] | Monitoring |
| Add error handling checklist to PR template | [name] | [date] | Process |
| Audit other background jobs for similar issue | [name] | [date] | Code |

**Action item criteria:**

- **Specific.** "Improve monitoring" is not actionable. "Add alert on connection pool saturation, threshold 80%, page on-call" is.
- **Owned.** A name. Not "the team."
- **Dated.** A real date. Not "soon."
- **Sized.** Roughly hours, days, or weeks of effort.
- **Closeable.** Definition of done is clear.

Action items that don't close in their committed timeframe should re-surface in the next AAR. Patterns of unclosed actions point to deeper organizational issues.

---

## Workflow

### 1. Schedule the AAR

Within 1 to 2 weeks of the event. Long enough that emotions cooled and facts gathered. Short enough that memories are fresh.

For incidents: pre-decided in the response procedure.
For launches: schedule on the runbook.
For projects: schedule at project closeout.

### 2. Gather inputs

Before the meeting:

- Reconstructed timeline (often the scribe's notes if there was one)
- Logs, chat transcripts, tickets, incident updates
- Individual accounts from each participant (written, before the meeting)
- Impact data (users affected, duration, revenue impact, etc.)

### 3. Run the meeting

Typical agenda (60 to 90 minutes):

- Read the summary as drafted (5 min)
- Walk the timeline together. Add corrections. Resolve disagreements. (20 to 30 min)
- Discuss root cause. Use five whys or causal chain. (15 to 20 min)
- Discuss contributing factors. (10 min)
- Discuss what went well. (10 min)
- Identify action items. Owners and dates. (10 min)

A facilitator runs the meeting. Often the IC for an incident, or a project lead for a project. The facilitator is not the scribe.

### 4. Write the document

Within a few days of the meeting. The full AAR includes all 6 sections.

### 5. Distribute

Internal: post in a known location. Make searchable. Reference in onboarding.

For high-severity incidents: external summary may be appropriate (status page, customer email, public blog).

### 6. Track action items

Every action item should be tracked to closure. The next AAR re-surfaces unclosed ones.

---

## Failure patterns

- **Skipping the AAR for "small" incidents.** Patterns get missed.
- **Naming and shaming.** Real lessons get hidden when people fear blame.
- **Generic action items.** "Improve testing" instead of specific testing change.
- **Action items that never close.** Filed, forgotten. Same incident recurs.
- **Theater retrospectives.** Going through the motions without genuine reflection.
- **Skipping "what went well."** Misses calibration on what's working.
- **Blame externalized.** "Our vendor failed." OK, what's our system for vendor risk?
- **Single-person AAR.** One person writes the whole thing. Misses other perspectives.
- **AAR only for failures.** Successful launches deserve AARs too. Lessons from success are valuable.
- **Long delays.** Memories fade. Conversations cool. Get it done within 2 weeks.

---

## Output format

A markdown document at `aar-[date]-[event-name].md`.

Structure:

```markdown
# AAR: [Event name]

**Date of event:** [YYYY-MM-DD]
**AAR date:** [YYYY-MM-DD]
**Severity / scope:** [SEV-1 / Major launch / Project closeout]
**Facilitator:** [Name]
**Participants:** [Names]

## Summary
[2 to 3 paragraphs]

## Impact
- Users affected: [number, segment]
- Duration: [time]
- Revenue / business impact: [if applicable]

## Timeline
[Timestamped events]

## Root cause analysis
[Five whys or causal chain]

## Contributing factors
[List]

## What went well
[List]

## Action items
| Action | Owner | Due | Type | Status |
|---|---|---|---|---|
| | | | | |

## Lessons
[Reflections that don't fit elsewhere. Often the most quotable section.]
```

---

## If required data is unavailable

This skill's output depends on data, measurements, or tool results it cannot generate on its own. When a required input, tool, or data source is unavailable or unverifiable, the sanctioned output is the deliverable with the gap stated: what was needed, what was actually obtained or verified, and which parts of the output are affected. Fabricating, estimating, or interpolating a required number to complete the deliverable is never sanctioned. A stated gap is a complete answer.

---

## Reference files

- [`references/aar-template.md`](references/aar-template.md) - Fillable AAR template covering incidents, launches, and projects.

© rampstackco · MIT · rampstackco/claude-skills

Similar skills

All skills for DevOps and infrastructure →
event-debrief Samuel Berthe The event-debrief skill runs the organizing team's internal retrospective on one finished edition: it rebuilds the timeline, splits wins from failures and produces a dated lessons-learned log. CX Codex +1 6,800installs project-retrospective jamditis project-retrospective creates LESSONS.md files that capture project knowledge and failures. Use when closing a project or investigation to record what worked, what didn't, and specific action items before the team moves on. CX Codex +1 189installs postmortem Alireza Rezvani postmortem runs a blameless 5 Whys review after a failed launch, missed target, or bad hire. It turns the findings into owned changes with review dates. CX Codex +1 1,465installs game-postmortem AlterLab-IEU game-postmortem — a skill for Claude Code, Codex, and Cursor that runs data-driven post-mortems on completed or canceled game phases. Collects Git metrics, issue logs, and AI costs into production/milestones/. CX Codex +1 ★ 57repo stars postmortem-generator Riccardo Carlesso (creator/maintainer) postmortem-generator is a Claude Code skill that turns incident context into a postmortem, timeline, action items, and a Google Doc draft. It starts after investigation and root-cause work. CX Codex +1 ★ 151repo stars create-github-action-workflow-specification official github The create-github-action-workflow-specification skill turns an existing GitHub Actions workflow into a formal specification for AI-assisted maintenance and review. CX Codex +1 10,745installs

From the same set102

The whole set →
seo-rank-tracking seo-rank-tracking structures rank tracking projects using Ahrefs MCP data, segmenting keywords into four buckets with clear baseline metrics and alert rules. CX Codex +1 294installs okr-design okr-design — a skill for writing outcome-based OKRs, choosing useful key results, and correcting weak scoring habits. Use it for quarterly planning or an OKR reset. CX Codex +1 293installs seo-content-gap-audit seo-content-gap-audit identifies topics your competitors rank for but you don't, and surfaces pages losing traction. Powered by Ahrefs MCP data, it builds a roadmap for what to create, update, or remove. CX Codex +1 293installs paid-media-strategy paid-media-strategy — a skill that structures how to spend ad money so it converts. Hypothesis discipline, channel selection, budget splits, audience targeting, bid strategies, and the failure modes that drain accounts. CX Codex +1 292installs content-brief-authoring The content-brief-authoring skill helps shape a brief for one piece of content, from search intent and audience to outline and success criteria. Use it to guide a writer or review an existing brief. CX Codex +1 292installs jtbd-framing jtbd-framing is a Claude Code skill that applies Jobs-to-be-Done to product work. It activates for JTBD analysis, prioritization, and product positioning. CX Codex +1 291installs email-sequences The email-sequences skill plans and drafts email campaigns, from onboarding flows and newsletters to transactional messages and win-back sequences. CX Codex +1 291installs seo-site-health-audit The seo-site-health-audit skill reranks crawler results (Ahrefs, similar tools) by actual impact on rankings instead of issue count. It helps you decide which technical fixes to tackle first when dev time is limited. CX Codex +1 291installs

Project sponsors

Companies that keep this analytics open