Skip to main content
skill CX Codex

incident-response · rampstackco — Claude Code skill: incidents and setup

The incident-response skill guides active production incidents from detection to closure, with severity checks, mitigation choices, roles, and communication steps.

MIT 277 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 incident-response -a claude-code
Open on GitHub

What incident-response does

The skill structures incident work into five phases: detection, triage, mitigation, communication, and resolution. It covers SEV-1 through SEV-4, assigns responsibilities to an incident commander, communications lead, operations lead, and scribe, and sets conditions for closing the incident.

For immediate impact, it lays out options such as rollback, disabling a feature flag, failover, scaling, throttling, graceful degradation, and maintenance mode. It also sets update cadences for the response team, internal stakeholders, and customers through a status page. The approach does not depend on a specific stack or toolset.

Before using it, prepare incident awareness, access to production systems and monitoring, clear role authority, and working communication channels. Without production access and monitoring, the triage process cannot cover the affected systems.

What it helps with

  • classify a production outage by severity
  • assign incident roles and decision authority
  • choose a mitigation for active user impact
  • plan updates for teams and customers
  • define checks for incident resolution

Example prompts for the agent

  • Analyze this active production incident, assign a SEV level, and list the first response steps.
  • Create an incident response plan for this outage with roles, mitigation options, and communication timing.
  • Draft an incident procedure with escalation rules and clear closure criteria.

How to install incident-response

1Skills CLI (Vercel)

npx skills add rampstackco/claude-skills --skill incident-response -a claude-code

2Manually: put the files in place

~/.claude/skills/incident-response/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/incident-response/

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

Questions about incident-response

How do I install incident-response in Claude Code?

Run npx skills add rampstackco/claude-skills --skill incident-response -a claude-code, then check ~/.claude/skills/incident-response/SKILL.md.

What does incident-response do?

It guides an active production incident through detection, triage, mitigation, communication, and verified resolution.

What does the skill need before it can be used?

It needs incident awareness, access to production systems and monitoring, defined roles with authority, and operational communication channels.

Source text

SKILL.md · MIT
---
name: incident-response
description: "Manage active production incidents through detection, triage, mitigation, communication, and resolution with structured roles and decision-making. Use this skill whenever the user has an active incident, a production issue, a service outage, a security incident, or needs to plan incident response procedures. Triggers on incident response, production incident, outage, service down, site down, P0, P1, severity, downtime, on-call, incident commander, status page, postmortem prep. Also triggers when something is actively broken in production and the user is figuring out what to do."
category: operations
catalog_summary: "Incident triage, comms, mitigation, escalation"
display_order: 2
---

# Incident Response

Manage active production incidents from detection to resolution. Stack-agnostic. Tool-agnostic.

This skill is for active incidents and incident process. For after-the-fact analysis, use `after-action-report`. For planned launches, use `launch-runbook`.

---

## When to use

- An active incident is happening
- Building incident response procedures
- Defining severity levels
- Setting up on-call rotations
- Training a team on incident response

## When NOT to use

- Post-incident retrospective (use `after-action-report`)
- Planned launches (use `launch-runbook`)
- Pre-launch issue triage (use `qa-testing`)

---

## Required inputs

- Awareness of the incident (alert, customer report, internal observation)
- Access to production systems and monitoring
- Roles and authorities clearly defined
- Communication channels operational

---

## The framework: 5 phases

### 1. Detection

How the incident becomes known.

**Detection sources:**

- Automated alerts (monitoring, SLO violations, error rate spikes)
- Customer reports (support tickets, social media, status page subscribers)
- Internal observation (engineer notices something off)
- Third-party (security researchers, partners)

**On detection:**

- Acknowledge within target time (typically 5 to 15 minutes for critical)
- Assess severity (see severity rubric below)
- Page the on-call if not already paged
- Open the incident channel

### 2. Triage

Establish severity and impact.

**Severity rubric:**

| Severity | Definition | Response |
|---|---|---|
| SEV-1 (Critical) | Major customer-facing functionality broken. Data integrity at risk. Security breach. | All-hands. Incident commander. Active war room. Public communication required. |
| SEV-2 (Major) | Significant degradation. Some customers affected. Revenue impact. | Incident commander assigned. Active response. Internal communication. May or may not need public communication. |
| SEV-3 (Minor) | Limited impact. Workaround available. Affecting a small group of users. | Standard on-call response. Single owner. |
| SEV-4 (Low) | Cosmetic, edge-case, or low-frequency. No urgent action needed. | Tracked as bug. Addressed in normal queue. |

Severity can change. Re-evaluate as more info emerges.

### 3. Mitigation

Stop the bleeding before fixing the cause.

**Mitigation patterns (faster than full fix):**

- **Rollback** (revert recent deploy)
- **Feature flag off** (disable the broken feature without deploy)
- **Failover** (route to healthy replica or region)
- **Scale up** (more capacity to absorb the load)
- **Throttle** (reject some traffic to protect the rest)
- **Graceful degradation** (turn off non-essential features to keep core functional)
- **Maintenance mode** (last resort, blocks all users)

**Mitigation principle:** Stop user impact first. Cause analysis second.

### 4. Communication

Three audiences during an incident:

**Internal team:**
- Real-time updates in incident channel
- Cadence: every 15 minutes minimum during active incident
- Format: timestamped status updates with what we know, what we're doing, ETA

**Internal stakeholders:**
- Higher-level updates to broader org
- Cadence: every 30 to 60 minutes
- Format: business-impact framing, not technical detail

**External / customers:**
- Status page updates
- Cadence: every 30 minutes minimum during active incident
- Format: plain language, no blame, what users are experiencing, what to expect

**Communication principles:**
- Acknowledge before you have answers ("We're aware and investigating")
- Update on schedule even if no progress ("Still investigating, no new information")
- Never speculate publicly about cause
- Confirm resolution explicitly when restored

### 5. Resolution

Verified fix, customers restored, incident closed.

**Resolution criteria:**

- Mitigation in place and verified
- Root cause identified (or explicitly deferred to AAR)
- All affected systems back to normal
- Customers can resume normal use
- Final status update posted (internal and external)
- Incident channel can be closed (or archived for AAR)

After closure:
- Schedule AAR within 1 to 2 weeks
- Capture initial timeline while memories are fresh
- Track follow-up action items

---

## Roles during an incident

| Role | Responsibility |
|---|---|
| Incident commander (IC) | Owns the response. Calls decisions. Assigns work. Not necessarily the most technical person; needs to coordinate. |
| Communications lead | Owns internal and external messaging. Reduces IC's communication burden. |
| Operations lead | Drives the technical investigation and mitigation. Often the most senior on-call engineer. |
| Scribe | Captures the timeline as the incident unfolds. Critical for AAR. |
| Subject matter experts | Pulled in as needed. Service owners, database experts, security experts. |

For small teams or low-severity incidents, one person can hold multiple roles. Each role's responsibilities should still be explicit.

---

## Decision-making during an incident

**The IC's authority:**

- Call rollback or other mitigations
- Pull additional people in
- Escalate severity
- Make the call when unclear options exist

**Non-decisions to avoid:**

- "Let's wait and see" when mitigations are available and impact is occurring
- Discussing root cause while users are actively impacted (mitigate first)
- Premature resolution announcements before verification
- Death-by-committee (pull in lots of people, no one decides)

When in doubt: act. A wrong action that can be rolled back beats inaction while users suffer.

---

## Status page communication patterns

**Initial:**
> "We are investigating reports of [issue]. Updates to follow."

**Identified:**
> "We have identified the issue affecting [scope]. Engineers are working on a fix. Next update by [time]."

**Monitoring:**
> "A fix has been applied. We are monitoring to confirm resolution. Next update by [time]."

**Resolved:**
> "This incident has been resolved. Service has been restored. A full incident report will be posted within [timeframe]."

Patterns to avoid:

- Vague language ("experiencing some issues" - what kind?)
- Missing affected scope ("login is down" - everywhere or just one region?)
- Missing time commitments
- "Should be resolved soon" without verification
- Using "back up" before verification

---

## Workflow

1. **Acknowledge.** First responder acknowledges within target time.
2. **Assess severity.** Use the rubric. Open the appropriate response channel.
3. **Assign roles.** IC, comms, ops at minimum.
4. **Communicate.** Initial status update. Internal channel active.
5. **Investigate.** Logs, metrics, recent changes. The four most common causes: a recent deploy, a configuration change, a third-party dependency change, a load spike.
6. **Mitigate.** Stop the bleeding. Don't wait for full root cause.
7. **Verify mitigation.** Don't trust dashboards alone; test the user flow.
8. **Communicate resolution.** Internal and external.
9. **Close incident.** Final timeline noted. Action items tracked.
10. **Schedule AAR.** Within 1 to 2 weeks.

---

## Failure patterns

- **No clear IC.** Multiple people debugging in parallel, no coordination. Slower to mitigate, easier to make conflicting changes.
- **Skipping mitigation, going straight to root cause.** Users keep suffering while engineers debug.
- **Premature "all clear."** Announcing resolution before verification.
- **Communication silence.** Users don't know if anyone is working on it.
- **Status updates too vague.** "We're working on it" with no detail.
- **Speculating publicly about cause.** Often wrong, always damaging trust.
- **Pulling in too many people.** Coordination overhead exceeds value.
- **No scribe.** The timeline gets lost. AAR has to reconstruct from chat logs.
- **Skipping AAR for "minor" incidents.** Patterns get missed. Lessons get re-learned.
- **Blame culture.** People hide mistakes, incidents take longer.

---

## Output format

During an active incident: incident channel updates and status page updates as per the framework above.

After incident close: a brief incident summary feeding into the AAR.

```markdown
# Incident: [Brief title]

**Date:** [YYYY-MM-DD]
**Severity:** [SEV-1 / 2 / 3 / 4]
**Duration:** [Detection to resolution]
**Customer impact:** [Who, how many, how, or state the gap per the data-availability rule]

## Summary
[1 to 2 paragraphs]

## Timeline
[Timestamped events]

## Mitigation
[What was done]

## Action items
[Follow-ups, with owners]

## AAR scheduled for
[Date]
```

---

## 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/incident-playbook.md`](references/incident-playbook.md) - Severity definitions, roles, status page templates, decision rubrics.

© rampstackco · MIT · rampstackco/claude-skills

Similar skills

All skills for DevOps and infrastructure →

incident-response by other authors comes first.

incident-response official anthropics incident-response walks an incident from detection to review: severity triage, status updates, timeline and a blameless postmortem. CX Codex +1 6,100installs incident-response Alireza Rezvani incident-response sorts a fired alert into one of 14 incident types, filters false positives, and tells you who to page and what to preserve. CX Codex +1 634installs incident-response devops-skills Handles security breaches and system compromises using structured six-phase incident response playbooks and Linux forensic collection scripts. CX Codex +1 455installs incident-response spencerpauly The incident-response skill for Claude Code guides production outage response, from severity triage and quick mitigation to coordinated updates and blameless postmortems. CX Codex +1 420installs incident-response microsoft incident-response guides SRE and operations teams through Azure incident triage, diagnostic query writing, mitigation plans, and root cause documentation. CX Codex +1 ★ 1,627repo stars incident-response-plan aj-geddes The incident-response-plan Claude Code skill helps build procedures for security incidents. It applies to breach handling, response playbooks, and forensic investigations. CX Codex +1 488installs ai-sre-incident-response devops-skills ai-sre-incident-response — a skill for Claude Code, Codex, Cursor and other platforms: builds SRE practices for AI incidents — model outage, quality regression, cost explosion, safety violations. CX Codex +1 365installs incident-response-forensics securityskills incident-response-forensics — a skill for collecting and analyzing digital evidence during security incident investigations. Preserves proof without corruption, gathers ephemeral data, and constructs an attack timeline. CX Codex +1 254installs sre-incident-response paulip114 sre-incident-response is a Claude Code skill that structures production outage management using Google IMAG methods. Responders deploy generic mitigations first and triage systematically. CX Codex +1 ★ 67repo stars supply-chain-incident-response W4L33Dx supply-chain-incident-response is a Claude Code skill for investigating a compromised dependency or vendor. It identifies affected versions, exposed environments, and recovery steps. CX Codex +1 ★ 73repo stars Incident Response taste f The Incident Response taste prompt for ChatGPT sets out how a calm on-call engineer can handle incidents. It calls for early declaration and coordinated response before the root cause is known. GP ChatGPT ★ 178,201repo stars

From the same set102

The whole set →
feature-launch-playbook feature-launch-playbook — an operational guide to launching features: positioning, sales and support enablement, rollout strategies with rollback triggers, and measuring post-launch metrics. CX Codex +1 280installs upgrade-flow-design The upgrade-flow-design skill plans SaaS free-to-paid journeys, including paywall timing, upgrade paths, win-back flows, and churn prevention. CX Codex +1 279installs dependency-management dependency-management turns third-party packages into a policy: how often to update, how fast to patch, and whether a new library earns its place. CX Codex +1 278installs user-feedback-aggregation user-feedback-aggregation — a skill for collecting user feedback across channels (support tickets, NPS, in-app, calls, social, customer councils) and turning it into a decision signal. CX Codex +1 278installs integration-orchestrator integration-orchestrator — a skill that builds a delivery plan for creative-direction projects: which phases run when, where decisions lock, who verifies what, and how to implement it in Jira, Linear, or Figma with agents. CX Codex +1 276installs beta-program-management beta-program-management guides product teams through running structured closed and open betas, participant selection, and clear graduation criteria for general availability. CX Codex +1 275installs feature-flagging The feature-flagging skill for Claude Code covers the operational lifecycle of feature flags, from flag types and rollout strategies to stale flag cleanup. CX Codex +1 273installs team-onboarding-playbook team-onboarding-playbook builds structured 30-60-90 day ramp-up playbooks for new hires, contractors, and re-structured teams. CX Codex +1 273installs

Project sponsors

Companies that keep this analytics open