Runbook Writer

    2

    Turn alerts and postmortems into step-by-step runbooks an on-call engineer can follow at 3am, with every unknown marked instead of guessed.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Runbook Writer

    Example session with this skill installed

    Draft a runbook for the KubePodNotReady alert. I've attached the Prometheus rule. We usually check logs in Kibana, but if it's a resource issue, we scale the deployment.

    • Read your context and instructions
    • Compiled the runbook writer

    I have drafted the runbook for KubePodNotReady based on the Prometheus rule provided and your notes. I have separated the investigative steps from the scaling mitigation and included mandatory warnings for state changes.

    Runbook: KubePodNotReady

    Service Owner: TO CONFIRM: Service Team
    Severity: P2
    Escalation: Platform Engineering (#ops-internal)

    1. Triage & Diagnosis

    1. Check Pod Status:
      Run kubectl get pods -n <namespace> -l <label-selector>
      • If Pending: Check for unschedulable nodes (Step 1.2).
      • If CrashLoopBackOff: Check application logs (Step 1.3).
    2. Resource Constraints:
      Run kubectl describe pod <pod-name> -n <namespace>
      • Look for "Events" indicating OOMKilled or FailedScheduling.
    3. Log Analysis:
      Access the Kibana Dashboard [Link TO CONFIRM] and filter by kubernetes.pod.name.
      • Identify recurring stack traces or connection timeouts.

    2. Mitigation (Scaling)

    WARNING: Scaling a deployment will trigger a rolling update or new pod creation. Ensure the underlying node capacity is sufficient before proceeding.

    1. Horizontal Scale:
      Run kubectl scale deployment <name> --replicas=<current+1> -n <namespace>
      • Expected Result: A new pod enters Running state within 120s.
      • If fails: Revert scale and escalate to Platform Engineering.

    3. Verification

    • Check the Prometheus metric kube_pod_status_ready{condition="true"}.
    • Threshold: Value must be >= 1 for at least 5 minutes.

    4. Rollback

    • Run kubectl scale deployment <name> --replicas=<original-count> -n <namespace>

    Next steps

    • Provide the Kibana dashboard URL to replace the placeholder.
    • Verify the specific kubectl namespace and deployment name used in this service.
    • Perform a dry-run of the scaling command to confirm the responder has patch permissions.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Operational runbooks written during an incident or from memory are often vague, dangerous, or missing critical branches. When responders are paged at 3am, they need exact commands, clear warnings, and verified signals rather than "investigate further." This skill transforms raw alert definitions, incident postmortems, and rough notes into structured, safety-first operational guides.

    What it does

    • Alert Inventorying scans Prometheus, CloudWatch, and Datadog definitions to scaffold runbook stubs for every firing alert.
    • Incident Synthesis converts postmortem threads and chat logs into generalized procedures that address failure classes.
    • Safety-First Drafting prioritizes read-only triage, mandates rollback steps, and places warnings before any state-changing command.
    • Automated Linting flags vague instructions, missing escalation paths, and risky commands lacking explicit approval steps.
    • Gap Identification explicitly marks missing operational facts as TO CONFIRM items rather than making dangerous guesses.

    How it works

    1. Source Analysis where you provide alert YAMLs, incident logs, or existing wiki pages for the agent to ingest.
    2. Drafting using a standardized template that separates diagnosis, mitigation, verification, and escalation.
    3. Internal Review where the agent lints the draft against strict operational writing standards to remove ambiguity.
    4. Handoff providing a list of untested commands and a categorized list of questions for specific stakeholders.

    Frameworks & tools

    This skill uses Python scripts for static analysis of PrometheusRule objects, CloudWatch alarm exports, and Datadog monitor JSON. It follows SRE best practices for incident response and operational documentation.

    Why this beats prompting it yourself

    Standard LLM prompts often hallucinate plausible-looking but incorrect CLI flags or omit crucial "what if this fails" branches. This skill enforces a "no-guesswork" policy, ensuring that every command and threshold is sourced directly from your infrastructure code or explicitly marked for verification.

    Use cases

    • Scaffolding documentation for a new service by scanning its Prometheus alert rules.
    • Converting a Slack incident thread into a permanent, reusable playbook for future responders.
    • Auditing existing runbooks to find missing rollback procedures or outdated escalation contacts.
    • Hardening on-call guides by adding "Expected Result" checks to every manual step.

    Known limitations

    The agent cannot execute commands or verify them against a live environment. It reads static alert definitions but does not expand complex YAML anchors, templates, or dynamically generated rules.

    Cannot verify command accuracy against live systems. Does not support YAML anchors or complex template expansion. Static analysis only; cannot access dashboards or metadata for truth.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Write Files
    Read Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The skill is designed to work with all major LLM-based agents that support document parsing, such as ChatGPT, Claude, and specialized SRE-focused platforms. It accepts standard exports from Prometheus, CloudWatch, and Datadog to ensure data accuracy.

    Unlike general AI models that may guess CLI flags, this skill follows a strict 'no-guesswork' protocol that prioritizes read-only triage and mandates rollback steps. It includes a specialized linting process that flags vague instructions and missing escalation paths, which standard prompts often overlook.

    Setup is straightforward; you simply provide your alert YAMLs, incident logs, or existing wiki pages as input sources. The skill then guides you through an internal review process where it lints the drafts against operational standards before providing a final handoff.

    You will receive the core Runbook Writer skill logic, a library of standardized SRE templates, and the specialized Python scripts used for static analysis of your infrastructure code. The package also includes a guide on interpreting the agent's 'Gap Identification' flags.

    The agent is designed to be 'safety-first' by explicitly marking any missing facts or untested commands as 'TO CONFIRM' rather than making assumptions. While it cannot execute commands in your live environment, it ensures that your human responders have verified signals and clear warnings before taking action.

    New in DevOps & Cloud