# handoff

Adopt this skill: https://proskills.md/skills/other/anthropics-oncall-kit-skills-handoff

Page: https://proskills.md/skills/other/anthropics-oncall-kit-skills-handoff
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/handoff/SKILL.md
size: 4695
sha: 3c6202758821d4dff4ba23345c4446c9c488903a
upstream: https://github.com/anthropics/oncall-kit/blob/main/skills/handoff/SKILL.md

```text
---
name: handoff
description: >
  Write the weekly on-call handoff: everything the incoming on-call needs,
  triage-ready, posted to the channel at shift boundary. Use when the weekly
  routine fires, or when someone asks for a handoff / shift summary / "catch
  the next on-call up".
---

<!-- Copyright 2026 Anthropic PBC -->
<!-- SPDX-License-Identifier: Apache-2.0 -->

# Handoff

Standing rules in `CLAUDE.md` apply — especially rules 10 and 11: fresh
reader, lead with what to do. The incoming on-call missed everything; this
document is their entire week's context, and it must arrive as **work they
can start**, not "here's what happened".

## Sources — sweep all of them

Fan out across every capability in `STACK.md` for the shift window
(default: the week since the last handoff):

- `pager` — every page and incident: state, severity, resolution
- `alert-channels` — what fired, what people said, what never got a thread
- `code` — merges/PRs touching on-call-relevant paths; reverts; deploys
- `metrics` — week-over-week trend of the health signals in `ONCALL.md`
- `lessons.md` — every entry appended this shift
- each incident record's history over the shift window

Cross-reference: an alert with no thread, a lessons entry with no incident,
a metric trending wrong with no alert — these orphans are usually the "watch
this week" items.

## Format

Post to the channel as a message with the exec summary, full doc attached or
linked:

> 📋 **On-call handoff — week of {{date}}**
>
> **Exec summary:** N incidents (n resolved, n monitoring). N pages.
> Anything systemic in one clause.
> **On-call health:** the required weekly metric — incidents and pages
> vs. last week, split by business-hours / off-hours, false pages, the
> **rubber-stamp fraction** (diagnoses acted on with no recorded
> verification step — the early warning that humans stopped
> cross-examining; see eval/replay.md), and whether the trend is up or
> down. This section is how the whole setup is
> measured over time (see eval/replay.md), so never omit it and never
> soften it.
> **Intake health:** median and worst time from symptom onset to incident
> declared this week (onset from the alert/thread timeline; declaration
> from the incident record). If incidents routinely run 40 minutes before
> anyone declares one, that's the process finding of the week — you can't
> fix an intake path you don't measure.
> **Watch this week:** the 1–3 things most likely to page you, each with
> why and a link to its pattern (`lessons.md` tag or reference file).
> **Start here:** the single highest-priority open item, with its current
> state and next action.
> **Full doc:** [link] · New to this channel? Read `ONBOARD.md` — how to
> read a diagnosis, challenge one, or silence a routine.

The full doc, per incident: **what happened** (one fresh-reader sentence,
links) · **what it means** (pattern or one-off? systemic risk?) · **what you
should do** (nothing / monitor / action, with the action named).

Then: open items ranked by "will this page you?", not by age. Preventable
repeats called out as playbook gaps with proposed reference-file amendments
(rule 9 — fix the playbook, not just the incident).

## Drift check (required section)

The ground moves between incidents; this is where the kit notices. Each
week, flag:

- any `STACK.md` binding that failed or 403'd during the week's work
- any reference file whose first-checks cite a tool or query that no
  longer responds
- anything in the `deploys` feed or announcement channels suggesting the
  infrastructure changed under the playbooks — a migration completed, a
  tool replaced, a service renamed
- the routine registry vs. reality: does the "Standing work" canvas match
  the channel's actual routines? Fix the registry; flag any routine that
  exists but was never registered
- open incidents with no update in >{{72h}} — the zombie list, each with
  its three-leg staleness evidence per ONCALL.md's lifecycle section,
  framed as "close it or update it", never closed by Claude (rule 2)

Each flag arrives as a proposal, never an edit (rule 9): "re-run Discover
for this binding," a reference-file amendment PR, or "re-run the replay
against post-change incidents" (see eval/replay.md's re-validation
triggers). A quiet week with no drift gets one line: "no drift detected."

## Discipline

- "Here's what happened" without "start here" is a diary, not a handoff —
  the priorities are the point.
- Never soften a preventable repeat. Write it plainly: "2 auto-reverts,
  both preventable."
- If the week was quiet, say so in two lines and stop. Padding a quiet week
  erodes trust in loud ones.
```

## File: README.md
upstream: https://github.com/anthropics/oncall-kit/blob/main/README.md

````text
<!-- Copyright 2026 Anthropic PBC -->
<!-- SPDX-License-Identifier: Apache-2.0 -->

# On-Call Kit

![The on-call loop: alert fires → Claude investigates → human decides → lessons learned feed back](assets/hero.svg)

Put Claude in your team's incident channel. When an alert fires, it
investigates and posts a first-pass diagnosis with a link behind every
claim. A human decides what to do. Claude then watches the fix land and
writes down what was learned, so the next incident starts smarter.

> **Reference implementation. Not maintained and not accepting contributions.**

This is the kit behind [the blog post](https://claude.com/blog/ai-ci-cd-on-call)
on building a CI on-call with Claude: the playbooks, templates, and a
guided setup that drafts those playbooks from your team's own incident
history. (Throughout: a **skill** is a markdown instruction file that
tells Claude how to do one job — triage an alert, write a handoff. You
review and change skills like code.)

Two properties worth knowing up front:

- **It works with whatever tools you already use.** No skill names a
  specific vendor. Skills refer to *capabilities* — the metrics source,
  the log store, the pager, the code host — and one generated file,
  `STACK.md`, maps each capability to the tool your channel actually has
  connected. Swap Datadog for Grafana, or PagerDuty for Opsgenie, and no
  skill changes.
- **You don't write the playbooks from scratch.** Setup reads your
  team's past incidents — alert threads, pager history, postmortems —
  and drafts the playbooks from what your team actually did. You review
  and correct the drafts.

## Try it in 10 minutes

Zero connections, zero admin. Clone this repo anywhere, open Claude Code
in it, and paste the one instruction from `test-fixtures/RUNBOOK.md`.
You'll watch the whole setup run against a fictional team's 48-incident
history: mining, playbook drafting, the sign-off gates, a graded
validation against an answer key. Nothing real is touched, so there is
nothing to clean up if you stop here.

The fixture doubles as the kit's regression test: change a skill, re-run
it, diff against the key.

## What you get

One Slack channel where:

- an alert landing in a watched channel (or a human declaring an
  incident) starts an investigation automatically
- Claude posts a grounded first-pass diagnosis — every claim linked to
  the log line or dashboard panel behind it — and **proposes** a fix
- a human decides, a human (or gated automation) deploys, and Claude
  watches the metrics land back at baseline
- anyone can ask for status on demand ("safe to merge?") and get an
  answer grounded in the open incident records
- every incident appends to `lessons.md`, so the next investigation
  starts smarter
- Monday morning, the handoff writes itself

The division of labor is fixed and non-negotiable (see `CLAUDE.md`):
Claude gathers evidence, proposes, verifies, and communicates. **Humans
decide what to mitigate and when.**

## Words this kit uses

Eight terms, defined once:

- **Capability binding** — the line in `STACK.md` mapping an abstract
  capability ("metrics") to your real tool ("Grafana").
- **Routine** — a standing task Claude runs in the Slack channel on a
  schedule or trigger ("watch #ci-alerts", "post the handoff Monday
  9am"). You create one by pasting or saying the request in the channel;
  anyone in the channel can list or disable them.
- **Canvas** — Slack's built-in document attached to a channel. The kit
  uses one to list the channel's routines and, optionally, to hold the
  weather report.
- **Shadow period** — the trial phase: Claude posts diagnoses to a
  review channel while humans handle incidents as before. It goes live
  only after its answers prove reliable.
- **Holdout** — a past incident deliberately kept out of playbook
  drafting, so it can serve as an unseen test in the Validate phase.
- **Provenance tag** — the annotation on every mined playbook claim
  saying how many incidents support it, e.g. `(seen 2×, unverified)`.
- **Page-tier vs. morning log** — the two urgency tiers: a *page* wakes
  a human now; a *morning log* line waits for the daily summary.
  `ONCALL.md` decides which is which.
- **MCP** — the connector protocol Claude uses to reach tools like your
  metrics source or pager. Your Claude org Owner attaches these
  connections (see `TAG-SETUP.md`).

## How it works: the incident loop

```mermaid
sequenceDiagram
    participant A as Alert channel
    participant C as Claude
    participant H as Human on-call

    A->>C: Alert fires
    Note over A,H: Page-worthy alerts page the human directly - Claude is never the detector
    C->>C: Classify the symptom,<br/>load the matching playbook,<br/>check past lessons
    C->>H: First-pass diagnosis with evidence links<br/>and a proposed fix
    H->>C: Pushback - could it be something else?
    C->>H: Checks the new hypothesis against the data,<br/>reports back either way
    H->>H: Decides on the fix and deploys it
    C->>H: Watches the metrics return to normal,<br/>confirms in the thread
    H->>H: Closes the incident - humans always close
    C->>C: Appends what was learned to lessons.md
```

Stage by stage:

| Lifecycle stage | Who/what |
|---|---|
| Detection | Your existing alerting stays primary: alerts fire into channels, and page-worthy ones page humans directly. Claude is never the detector. It watches the alert channels, triages what fires, and correlates across them — five alerts are often one incident. For a new service with no alerts yet, it drafts conservative starter rules for a human to install before launch |
| Diagnosis | The `triage` skill: classify the symptom, load the matching reference file, check `lessons.md` for known causes, post a grounded diagnosis with evidence links |
| Mitigation | **Human decides.** Claude proposes — including, where your team uses feature flags, a ready-to-execute canary ramp plan: the flag, the percentage steps, the hold time at each step, and the single metric that aborts the ramp. The human cross-examines, chooses, and deploys (or approves a gated action). The kit never touches a flag; it writes the plan a human runs |
| Verification | "Watch it land": Claude polls the affected metrics until baseline, posts confirmation |
| Communication | On-demand: anyone asks in the channel and gets a fresh-reader answer from the open incident records and ONCALL.md's health signals. Incident records are whatever your team already uses — threads, channels, pager incidents, tickets — bound in `STACK.md`, always opened by a human. Standing status is opt-in via the `weather` skill (see below) |
| Status (optional) | The `weather` routine: report written every cycle to one linkable page, channel posted only on event gates, always diffed against the last post the channel actually received — never against a report nobody saw |
| Learning | Every resolved incident appends to `lessons.md`; recurring patterns get promoted into reference files by PR |
| Handoff | The `handoff` skill, Monday morning: what happened / what it means / what you should do, triage-ready |

Open incidents move through four states. Every arrow into or out of the
closed states is a human action; the one arrow Claude drives is the
stale flag — an evidence-backed nudge, never a closure:

```mermaid
stateDiagram-v2
    [*] --> active: a human declares an incident
    active --> stale: quiet past the policy window
    stale --> active: a human posts an update
    active --> mitigated: a human ships a fix
    mitigated --> active: the symptom comes back
    mitigated --> resolved: a human confirms it is done
    active --> resolved: a human closes it
    stale --> resolved: a human closes it
    resolved --> [*]

    note right of stale
        Claude may flag an incident stale
        only on three independent signs
        of abandonment, and posts the
        evidence with the flag. It is a
        nudge, never a closure.
    end note
    note right of mitigated
 
````
