Skip to main content
Guide8 min read·Updated July 20, 2026
🧩

Best AI Agent Skills for Incident Postmortems in 2026

B

A. Frans

Published July 20, 2026

AI Agent SkillsIncident ResponsePostmortemsSREClaude Code

The worst part of an incident isn't the incident. It's writing the postmortem four days later, when the Slack thread has scrolled away, half the timestamps are in the wrong timezone, and the person who found the root cause is on vacation. So the document gets written from memory, the timeline is approximate, the action items are vague, and nobody reads it again.

An AI agent with access to your git history, your error tracker, and the incident channel can reconstruct that timeline in minutes instead of hours. It can pull the deploy that correlates with the error spike, quote the commit, and lay out what happened in order. What it can't do is decide what the organization should learn, and that distinction shapes how you should set this up.

Before the recommendations, a correction that applies to most articles you'll read on this topic, including some we published.

The install command most sites get wrong

There is no claude skill add command. It appears across a lot of skill directories and blog posts, it looks plausible, and running it gets you a command-not-found error. We carried it on this site too, which is worse than embarrassing on a site whose whole argument is verify before you install.

The documented ways to install a skill are these.

Through a plugin, from within a Claude Code session:

/plugin install superpowers@claude-plugins-official

If Claude Code reports that the marketplace isn't found, add it first:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Or by putting the skill on disk yourself:

mkdir -p ~/.claude/skills/incident-postmortem

Then write SKILL.md inside that directory. Personal skills live at ~/.claude/skills/<skill-name>/SKILL.md and work across all your projects. Project skills live at .claude/skills/<skill-name>/SKILL.md and ship with the repo.

That last distinction matters more than it looks, and there's a trap in it covered further down.

Quick comparison

Skill or serverWhat it contributes to a postmortemSourceInstall path
systematic-debuggingDisciplined root-cause process, resists first-guess answersobra/superpowersPlugin
verification-before-completionForces evidence before declaring anything resolvedobra/superpowersPlugin
subagent-driven-developmentParallel investigation across servicesobra/superpowersPlugin
Sentry MCPReal error data, stack traces, event timinggetsentry/sentry-mcpMCP server
Your own postmortem skillYour template, your severity levels, your blameless normsYou write itLocal file

Superpowers is the strongest general foundation

Jesse Vincent's superpowers is the most-starred skills collection in the ecosystem by a wide margin, sitting at roughly 257,000 stars and actively maintained. It isn't an incident tool. It's a set of engineering-discipline skills, and three of them carry most of the weight in a postmortem.

systematic-debugging is the important one. Its value in a postmortem is that it stops the agent from doing what humans do under time pressure, which is to grab the first plausible cause and write the document around it. Incidents usually have a chain, and the first plausible cause is usually a link in the middle. A skill that insists on working backward past the first answer produces meaningfully better root-cause sections.

verification-before-completion forces evidence before anything gets called done. Applied to action items, it's the difference between "we'll add monitoring" and a specific alert on a specific metric with a specific threshold and an owner.

subagent-driven-development matters for incidents that crossed service boundaries. It lets the agent investigate several services in parallel rather than serially reading its way through each one, which is where the time goes on distributed incidents.

Install the whole plugin rather than trying to extract individual skills:

/plugin install superpowers@claude-plugins-official

Sentry MCP for the data layer

Skills give an agent process. They don't give it your production error data. For that you need an MCP server, and Sentry maintains an official one at getsentry/sentry-mcp.

claude mcp add sentry -- npx -y @sentry/mcp-server

This is the piece that turns postmortem writing from recall into reconstruction. The agent can pull the actual error events, their first-seen timestamps, affected user counts, and stack traces, then line those up against your deploy history. The timeline stops being what people remember and starts being what the systems recorded.

Two cautions. Grant read-only scope, since a postmortem workflow has no reason to mutate anything in your error tracker. And be deliberate about what leaves your environment: stack traces and error payloads routinely contain user data, and an incident is exactly when people stop thinking carefully about that.

Other observability vendors publish MCP servers too. Check the vendor's own repository rather than a directory listing, because this is a category where fabricated package names circulate. Two of the three MCP install commands we checked in one popular skills database pointed at npm packages that don't exist.

The dedicated postmortem skill doesn't exist yet

Here's the honest state of the category. There is no widely adopted, well-maintained, incident-postmortem-specific agent skill. The directories will show you some, and most are thin wrappers around a prompt, unmaintained, or both.

That's fine, because a postmortem skill is one of the easier ones to write yourself, and it's one you should write yourself. Your severity definitions, your template, your blameless norms, and your action-item conventions are organization-specific. A generic skill would flatten exactly the parts that make postmortems useful at your company.

Create it:

mkdir -p ~/.claude/skills/incident-postmortem

A workable SKILL.md covers: your severity levels and what each requires; the sections of your template in order; an instruction to build the timeline from commits, deploys, and error events rather than from chat recall; an instruction to distinguish trigger from root cause; a requirement that every action item has an owner and a verifiable completion condition; and an explicit blameless framing that names systems and processes rather than people.

That last instruction earns its place. Left alone, models write "the engineer deployed without testing." What you want is "the deploy pipeline permitted a merge that skipped the integration suite." Same fact, and only the second one produces a fix.

Put it in the repo at .claude/skills/incident-postmortem/SKILL.md rather than in your home directory, so the whole team gets the same template.

The trap with personal skills

If a skill exists only in ~/.claude/skills/ on your laptop, Claude Code will report that it can't find the skill when a routine tries to invoke it, because each routine run starts as a fresh remote session with none of your local files.

This bites teams who build a postmortem skill, test it interactively, then wire it into automation and watch it fail. The fixes: commit the skill to the repository's .claude/skills/, ship it in a plugin declared in the repo's .claude/settings.json, or enable it for your claude.ai account for Cowork and cloud sessions. Plugins declared in the repo install at session start. Plugins enabled only in your user settings don't transfer.

Worth knowing before you build the automation, rather than after.

Composing them into a workflow

The sequence that works: MCP servers supply data, superpowers supplies investigative discipline, your own skill supplies the template and the organizational norms.

In practice you invoke your postmortem skill, and it uses the debugging discipline to work backward through the error data toward a root cause, then formats the result to your template. The agent produces a draft with a defensible timeline and a specific root cause.

Then a human does the part that matters. Deciding what this incident says about the system, which action items are worth the engineering time, and what the organization should change. An agent will happily generate fifteen action items, and a postmortem with fifteen action items is a postmortem with zero, because nobody does fifteen things.

Cut it to the two or three that would have prevented this class of incident. That's judgment, and it's the reason the postmortem meeting still needs to happen.

Security notes

Skills are instructions an agent follows, which makes an untrusted skill a prompt-injection vector rather than just bad advice. Read the SKILL.md before installing anything from a source you don't know. It's usually short, and reading it takes a minute.

Prefer official and verified sources. For plugin skills, the namespace is plugin-name:skill-name, so plugin skills can't silently shadow your own. Locally, precedence runs enterprise over personal over project, and a skill at any of those levels overrides a bundled skill with the same name. A skill named code-review in your project replaces the built-in one, which is a feature when you meant it and a surprise when you didn't.

For a fuller treatment, see our guide on auditing agent skill security.

FAQ

Is there a single skill that writes the whole postmortem?

Not a good one. The maintained skills give an agent investigative discipline; the template and organizational norms are yours to supply. Composing superpowers with a short skill you write yourself gets you further than any off-the-shelf postmortem skill currently available.

Do I need MCP servers, or are skills enough?

Skills alone give you process without data, so the agent writes from whatever is in the conversation. That's a marginal improvement over writing it yourself. Connecting at least your error tracker is what changes the output quality, because it replaces recall with recorded fact.

Why does the "claude skill add" command show up everywhere if it isn't real?

It's a plausible-looking command that propagated through skill directories and AI-generated posts, each one citing the last. It appears nowhere in the official documentation. Check any install command against the vendor's own repository or the official docs before running it, particularly for anything that touches your production systems.

Should the postmortem skill live in the repo or in my home directory?

The repo, for anything a team shares. Committed skills give everyone the same template and are the only version that works in routines and cloud sessions. Home-directory skills are for your own workflow preferences.

Can the agent decide severity?

It can apply your written severity definitions to the facts, which is useful and consistent. It shouldn't own the call on anything customer-facing or contractual, since severity often drives obligations that the model has no visibility into.

Share this article

📬

Get More AI Tool Guides

New comparisons and guides every week. Join thousands of professionals staying ahead of the AI curve.