gilde

← All craftbooks

On-Call Escalation Playbook

Comms and ops automationevalv1.0.0released 2026-06-05workflow: build-loop

Author an on-call escalation playbook: the severity ladder, who-to-page-when escalation tiers with timeouts, communication cadence to stakeholders, and the step-by-step actions for each severity. Scopes the severity definitions and escalation policy FIRST (SEV levels with concrete examples, tier timeouts, roles, comms channels and cadence), then a copywriter writes the playbook in clear, do-this-now imperative steps, then a reviewer validates it for completeness and that no severity dead-ends without an escalation path. Scoping the SEV ladder and timeouts before writing prose is what makes the playbook unambiguous at 3am. Use for on-call runbooks, incident escalation policy, paging tiers, severity ladders, and SRE escalation procedures.

Steps

Entry step: scope. Each step names the specialist role it wants; the full working prompt is expandable.

  1. Scope the policyplannerentry

    lock SEV levels, escalation tiers, timeouts, and comms

    Show working prompt
    Define the escalation policy before writing prose. (1) Lock a severity ladder (e.g. SEV1 critical/total outage, SEV2 major degradation, SEV3 minor) with a concrete example and an impact definition for each. (2) For each SEV, define the escalation tiers: who is paged first, the timeout before escalating to the next tier (e.g. 'no ack in 10 min → page secondary; 20 min → page EM'), and the final backstop. (3) Define the incident roles (Incident Commander, Comms lead, Scribe) and when each is invoked. (4) Lock the stakeholder communication cadence per SEV (channel + update frequency, e.g. SEV1 = status page + every 30 min). Write an acceptance-criteria checklist ('every SEV has impact definition + example', 'every SEV has a full escalation tier chain with timeouts ending in a backstop', 'roles defined and triggered per SEV', 'comms cadence specified per SEV', 'no SEV dead-ends without escalation') plus the ladder/tier tables to notes/scope.md via write_task_note AND the produces path. No prose playbook yet.
  2. Write the playbookcopywriter

    write do-this-now steps for each severity

    Show working prompt
    Write playbook.md from the locked policy as a 3am-readable runbook. (1) Open with the severity ladder table (SEV, impact, example) and a one-paragraph 'how to use this'. (2) For EACH severity, write a numbered, imperative step list — Detect & declare → Assign roles → Mitigate → Escalate (with the exact tier timeouts) → Communicate (channel + cadence) → Stand down. Use second-person commands ('Page the primary on-call. If no ack in 10 minutes, page the secondary.'). (3) Include the escalation tier chain inline for each SEV with the timeouts spelled out, ending in a backstop with no dead-end (a tier that escalates to nobody). (4) Add a Communications section with templated stakeholder update snippets per SEV. (5) End with a post-incident handoff/postmortem trigger. No ambiguity, no prose digressions — every line is an action or a fact. On a loop-back fix only the flagged sections. Write the path to notes via write_task_note.
  3. Evaluatereviewer

    Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.

    Show working prompt
    Validate playbook.md against every locked criterion. (1) Confirm every SEV from the scope has impact definition, example, and its own complete imperative step list (declare → roles → mitigate → escalate → communicate → stand down). (2) Trace each SEV's escalation chain end-to-end: are the tier timeouts present and does the chain end in a backstop with no dead-end (a tier that escalates to nobody)? FAIL if any SEV dead-ends. (3) Confirm roles are defined and their trigger points stated per SEV, and the per-SEV comms cadence + channels + templated update snippets exist. (4) Read 2 step lists for ambiguity — a tired on-call must be able to follow them literally. Write PASS/FAIL per criterion with the specific gaps.

Then route — this is the whole point of the loop:

- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: "evaluate", next: "finish" })`.
- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: "evaluate", next: "write" })` to loop back. The builder fixes exactly those gaps.

Never route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.
  4. Finishdeveloper

    All acceptance criteria met. Stamp a short summary and report DONE.

    Show working prompt
    Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.

Triggers

Phrases that suggest this craftbook to a crew.

Source

View this craftbook on GitHub · MIT license