sre is an open-source Agent Skill that makes AI coding agents work like a careful, experienced Site Reliability Engineer. It is installed as a single folder into tools such as Claude Code, Codex, Cursor, GitHub Copilot, Antigravity and Gemini CLI, and it activates for any reliability or production-operations question — you do not have to say "SRE" to invoke it. Its stated purpose is to give agents the habits good SREs follow on every page, every change and every postmortem: mitigate first, know the blast radius, and back every recommendation with real numbers. The project is released at version 1.1.0 under MIT / CC BY 4.0 and is distributed as a public GitHub repository that you clone once and link into each tool you use.
The skill starts from a specific complaint: general-purpose coding agents are fast and confident, but the advice they give about production systems can be ungrounded. The project's own framing is that advice without context is a guess, and in production the cost of a guess is paid by users. Good SRE practice is really a set of habits — mitigate before you diagnose, understand what a command will affect before you run it, prefer gradual and reversible changes, and keep what you verified separate from what you suspect. Those habits are documented in Google's Site Reliability Engineering (2016) and The Site Reliability Workbook (2018) and in LinkedIn's School of SRE, but they are not automatically part of how an AI agent behaves. The skill packages them so an agent applies them consistently, and cites the chapter each recommendation comes from so the reasoning can be checked.
Two behaviours sit at the front of the skill. "Mitigate first" means that when users are hurting, the agent rolls back, drains traffic or flips a flag before hunting for the root cause — root cause can wait. In the site's on-call example, where orders-api p99 latency is 4 seconds and MySQL replica lag is 900 seconds and climbing, the agent's first moves are to check what changed in the last hour (deploys, config, cron jobs) and, if a deploy lines up, to roll it back. Alongside this, "know the blast radius" means every command comes with what it affects, whether it can be undone, and how; risky operations are marked with a warning. A rollback is described as touching all pods but being reversible by redeploying the previous version.
Three more habits govern how the agent acts. "Change safely" asks for gradual, observable and reversible changes, citing the Workbook's finding that binary and config pushes cause about 68% of outages. "Confirm before acting" means read-only checks come first and anything that writes to production waits for an explicit yes — for example, recommending KILL QUERY rather than KILL because it keeps the connection, and confirming before running it. "Verify, don't assume" means the agent checks that the user-facing signal actually recovered and keeps what it saw apart from what it suspects; in the example, p99 back under the 300 ms SLO for 15 minutes and lag trending down before the incident is declared mitigated. Finally, "blameless, always" means asking what the system allowed rather than who did it, with action items that get owners and types.
The skill covers a defined set of production-operations topics. For live incidents it handles latency, 5xx errors, CPU, disk, DNS, TCP, MySQL replication lag and Kafka backlogs, applying mitigation first and read-only triage afterwards. For SLOs and error budgets it helps define SLIs based on what users actually feel, set realistic targets and write an error budget policy, and it pushes back on five nines with numbers. For alerting it favours multiwindow burn-rate pages over CPU alerts, along with ticket tiers and options for low-traffic services; Prometheus rules are included.
Beyond incidents, the skill supports reliability gap reviews — checking every component for SLOs, monitoring, redundancy, deploy safety and backups to answer "what's missing to make this reliable?" It writes blameless postmortems from messy notes, producing a UTC timeline, a trigger separated from causes, and owned and typed action items. It plans rollouts as canaries with a concurrent control group, abort criteria and rollback, treating config with the same care as code. It estimates capacity for machines, disk and network with real numbers, including N+2 headroom and what happens when each failure domain dies. And it covers teams: on-call sizing, toil budgets, pager load reviews, and how SRE works with dev teams.
A built-in Python calculator, sre_calc.py, works out budgets and alert thresholds so the agent doesn't have to guess. Its burn subcommand generates burn-rate alerts for a given SLO; the site shows, for 99.9%, thresholds of 2% of budget spent in one hour (14.4× burn rate, error ratio above 1.44%) paging, 5% in six hours (6.0×, above 0.6%) paging, and 10% in three days (1.0×, above 0.1%) filing a ticket. Other subcommands are downtime, budget, requests, lowtraffic, and compose for chained or redundant services. A worked example shows a Checkout API at a 99.9% SLO over a 28-day window: 62.0% of the budget used, 15.3 minutes left, 40.3 minutes allowed, 25.0 minutes down so far and 99.938% achieved — and above 50% used with half the window left, the error budget policy asks for extra review and a canary on every change.
The skill also ships reusable documents that the agent fills in for your system instead of inventing a format each time: an SLO document, an error budget policy, an incident state document, a postmortem template, a postmortem review checklist, a canary plan, a launch checklist, a capacity estimate worksheet, an on-call handoff template, a reliability gap assessment and an alerting pipeline health checklist. Each is a Markdown file in the repository's assets folder, so teams get a consistent structure across incidents and reviews.
Installation is deliberately minimal. The skill uses the open Agent Skills format, so you clone the repository once (to ~/sre-skill) and link it into each tool you use; for Claude Code that means creating ~/.claude/skills/sre as a symlink, restarting, and calling it with /sre or simply asking an SRE question. Before a review, SLO or alerting task, the skill is designed to learn your system first and save it as sre-context.md so every later session starts from there. It reads Terraform, manifests, code and alert rules read-only, then asks only what the files can't show: what the product is and who uses it, the two or three most important user flows, traffic, team size, on-call setup and whether SLOs exist today. With no repo access, it asks the same questions instead. In a live incident those questions are skipped, because mitigation comes first.
The stated benefit is judgment rather than speed: every recommendation is backed by real numbers and cites the chapter it comes from, so you can check the reasoning instead of trusting it. Risky commands are flagged before they run, writes to production wait for confirmation, and the agent distinguishes what it verified from what it suspects. Teams get consistent documents — the same SLO document, postmortem and canary plan formats every time — rather than a new format invented per session. And because the skill learns the system first, the advice is about your architecture rather than a generic pattern.
Concrete scenarios on the site include an on-call engineer facing a latency spike and climbing replica lag, where the skill sequences a change check, a rollback decision, read-only diagnostics and a verification step. Another is an SLO review where the error budget is 62% consumed with half the window left, triggering the policy's extra review and canary requirement. Others are designing burn-rate alerting instead of CPU-threshold pages, running a reliability gap review to rank missing monitoring and wrong alerts by user impact, writing a postmortem from messy incident notes, planning a canary with abort criteria, estimating capacity with N+2 headroom, and sizing on-call rotations.
The skill is aimed at the people who run production systems: SREs, on-call engineers, platform and infrastructure teams, and developers using AI coding agents who want reliability guidance grounded in field-tested practice rather than improvised. It is distributed as an open-source repository under MIT / CC BY 4.0, works with Claude Code, Codex, Cursor, GitHub Copilot, Antigravity and Gemini CLI, and ships a Python calculator plus Markdown templates. Its material is drawn from Google's Site Reliability Engineering (2016), The Site Reliability Workbook (2018), LinkedIn's School of SRE (CC BY 4.0) and personal experience. No book text is included; both Google books can be read free at sre.google/books, and the project states it is not affiliated with or endorsed by Google, O'Reilly or LinkedIn. Users can report bad advice or contribute through GitHub.
In short, sre gives AI coding agents the judgment of an experienced Site Reliability Engineer: mitigate first, know the blast radius, change safely, and back every recommendation with real numbers and a cited source.