claudeskills.page

25 skills · category

DevOps & SRE skills for Claude Code

Skills for the delivery path and the pager: lean Dockerfiles, Compose stacks, Kubernetes and Helm, Terraform, GitHub Actions and GitLab CI, Ansible, nginx, OpenTelemetry, log analysis, SLOs and error budgets, zero-downtime deploys, and incident response.

Download all 25 (.zip) Browse the list
  1. 146Ansible Playbooks
  2. 147Argo CD GitOps
  3. 148Blue-Green and Canary Deploys
  4. 149Chaos Engineering
  5. 150CI Pipeline Speed
  6. 151DNS and TLS Certificates
  7. 152Docker Compose
  8. 153Dockerfile Optimization
  9. 154GitHub Actions
  10. 155GitLab CI
  11. 156Grafana Dashboards
  12. 157Helm Charts
  13. 158Incident Response
  14. 159Kubernetes Autoscaling
  15. 160Kubernetes Deploy
  16. 161Linux Troubleshooting
  17. 162Log Analysis
  18. 163Nginx Reverse Proxy
  19. 164Nix Dev Environments
  20. 165OpenTelemetry
  21. 166Prometheus Alerting
  22. 167Pulumi IaC
  23. 168SLOs and Error Budgets
  24. 169systemd Services
  25. 170Terraform IaC

Every devops & sre skill

Each card opens the full playbook, example prompts and install commands.

No. 146

Ansible Playbooks

Second run, zero changes

Claude writes roles that use proper modules with validation instead of shell one-liners, routes restarts through handlers, and keeps secrets in Vault with no_log. Every change is linted, dry-run with check and diff on one host, applied as a canary and then in serial batches, and finally re-run to prove the recap shows changed=0 everywhere.

ansible-playbooks 223 lines
No. 147

Argo CD GitOps

Every cluster change is a reviewed, revertable commit

Claude lays out a config repo with overlays per environment, generates Applications from ApplicationSets inside locked-down AppProjects, and orders syncs with waves and PreSync hooks. It explains OutOfSync drift instead of papering over it, keeps secrets out of Git with External Secrets or Sealed Secrets, and makes production promotion a pull request that moves one image tag.

argocd-gitops 269 lines · 2 files
No. 148

Blue-Green and Canary Deploys

Ship gradually, roll back in one command

Claude first checks that both versions can run side by side, covering additive migrations, tolerant consumers and cron jobs that would run twice, then picks blue/green, canary or a flagged launch based on traffic. It wires per-version metric gates, shifts traffic in steps with bake time, and writes a rollback plan with triggers, commands and data caveats.

blue-green-deploys 208 lines
No. 149

Chaos Engineering

Break one thing on purpose, with an abort button

Claude plans fault injection the way a reliability team does: a written hypothesis against a user-facing SLI, a blast radius of one pod or one dependency, abort conditions, and a verified rollback before anything runs. It picks the right tool for the target, confirms the fault actually applied, and closes every experiment with a result, evidence and follow-up tickets.

chaos-engineering 246 lines
No. 150

CI Pipeline Speed

Shorten the critical path, prove it with medians

Claude baselines several recent runs with a bundled analyzer that finds the critical path, queue delay and slowest steps, then works on that path only: removing duplicate work, adding correctly keyed caches, sharding tests by timing data, and running affected-only builds in monorepos. Results are reported as before-and-after medians with test counts unchanged.

ci-pipeline-speed 171 lines · 2 files
No. 151

DNS and TLS Certificates

Records verified at the source, certs that renew themselves

Claude records current DNS before changing it, lowers TTLs ahead of migrations and checks answers at the authoritative nameservers instead of trusting a cached resolver. Certificates are issued with the right ACME challenge, served as a full chain, renewed on ARI or two-thirds of lifetime as validity periods shrink, and checked by a bundled script that verifies chain, SANs and days left.

dns-tls-certificates 197 lines · 2 files
No. 152

Docker Compose

One command to a working local stack

Claude builds compose.yaml files where the app waits for a healthy database instead of sleeping, migrations run as a one-shot service, ports bind to localhost, and optional tools sit behind profiles. It separates .env interpolation from container env, sets up Compose Watch for hot reload, and validates everything with docker compose config and up --wait.

docker-compose 226 lines
No. 153

Dockerfile Optimization

Smaller images, cached builds, no root, no leaks

Claude baselines image size and warm-build time, runs a bundled audit script, then restructures the Dockerfile into dependency, build and runtime stages with lockfiles copied before source. It picks a distroless or slim base, moves build secrets into BuildKit mounts, drops root, and reports before-and-after size, build time and CVE counts in a table.

dockerfile-optimization 232 lines · 2 files
★ No. 154

GitHub Actions

Faster CI, read-only tokens, zero stored cloud keys

Claude rewrites workflows so irrelevant changes skip CI, superseded runs cancel, and package and Docker caches make the warm path fast. Tokens default to read-only, deploys use OIDC with subject-restricted trust policies and protected environments, and untrusted PR text never reaches a shell. Results are linted with actionlint and zizmor and reported with before-and-after timings.

github-actions 227 lines · 2 files
No. 155

GitLab CI

One pipeline per change, jobs that start early

Claude adds workflow rules so branch and merge request pipelines stop doubling up, converts stage chains into a needs DAG, and separates lockfile-keyed caches from artifacts that later jobs rely on. Shared config moves into extends, includes and pinned CI/CD components, and deploys get protected environments, a resource group, a manual gate and OIDC tokens.

gitlab-ci 244 lines
No. 156

Grafana Dashboards

Broken, where, since when: answered in 30 seconds

Claude builds dashboards around the questions on-call actually asks: SLI stats on top, rate, errors and duration by route below, then saturation and dependencies. Queries use $__rate_interval and bucket-level percentile math, datasources are referenced by variable, and the JSON is provisioned from Git and checked by a bundled linter for hardcoded UIDs, missing units and vanity panels.

grafana-dashboards 200 lines · 2 files
No. 157

Helm Charts

Charts that render clean and upgrade safely

Claude designs a small, documented values surface with a JSON schema, writes templates on shared helpers with immutable selector labels, and adds checksum annotations so config changes roll pods. Before any upgrade it lints, renders every environment's values through kubeconform, diffs against the live release and upgrades with wait and automatic rollback.

helm-charts 242 lines
No. 158

Incident Response

Stop the bleeding first, explain it later

Claude acts as scribe, analyst and comms drafter during an outage. It sets severity, correlates the error inflection point with recent deploys and config changes, proposes one reversible mitigation at a time with expected effect and rollback, and waits for approval. It keeps a UTC timeline and drafts internal and status page updates on a fixed cadence.

incident-response 169 lines · 2 files
No. 159

Kubernetes Autoscaling

Scale on the right signal, before latency breaks

Has Claude treat autoscaling as one system: requests set from measured usage, a scaling signal that leads saturation, HPA behavior tuned against flapping, KEDA for queues and scale to zero, and Karpenter or Cluster Autoscaler sized to provisioning time. It keeps VPA and HPA off the same metric, writes PDBs that let nodes drain, and ships a simulator that replays a load curve through the HPA math.

kubernetes-autoscaling 331 lines · 2 files
No. 160

Kubernetes Deploy

Rollouts that finish, pods that stay up

Claude checks the kube context before touching anything, writes Deployments with startup, readiness and liveness probes that mean different things, sizes requests from observed usage, and adds PDBs, spread constraints and a preStop drain. When pods fail it walks a status-to-cause table using describe, logs --previous and ephemeral debug containers instead of guessing.

kubernetes-deploy 225 lines · 2 files
No. 161

Linux Troubleshooting

Name the saturated resource, with evidence

Claude runs a read-only 60-second checklist before touching anything, then follows the evidence to the saturated resource: run queue, D-state tasks, swapping, disk await, socket backlogs or fd limits. A bundled vmstat analyzer ranks suspects from captured output, and every finding ends with the responsible process, the cause and a mitigation that waits for your approval.

linux-troubleshooting 174 lines · 2 files
No. 162

Log Analysis

Count, compare to baseline, then read

Claude pins the question and a UTC window, finds the minute errors departed from normal, and groups messages into normalized signatures so new failures stand out against a baseline period. It follows a single request across services by correlation ID, lines the spike up with deploys, and reports findings with the exact queries and redacted sample lines.

log-analysis 165 lines · 2 files
No. 163

Nginx Reverse Proxy

Proxy configs proven with curl, not hope

Claude dumps the effective nginx config before editing, writes upstreams with keepalive and correct forwarded headers, and sets up TLS with automated renewal or a short Caddyfile when that fits better. It avoids the add_header inheritance trap, adds rate limits and caching only where safe, and proves each behavior with nginx -t, curl and openssl before reloading.

nginx-reverse-proxy 241 lines
No. 164

Nix Dev Environments

One command, the exact tools CI uses

Claude inventories the tool versions a project really uses, then writes a flake.nix devShell for every platform the team runs, pinned by a committed flake.lock and activated automatically with nix-direnv. CI enters the same shell with a binary cache, application dependencies stay in their own lockfiles, and teams that do not want full Nix get devbox, devenv or mise instead.

nix-environments 241 lines
No. 165

OpenTelemetry

One request, one connected trace

Claude starts with zero-code instrumentation and a local Jaeger so output is visible immediately, then adds manual spans around business operations, propagates W3C context through HTTP and message queues, and links logs to traces. Telemetry goes through a Collector with memory limits, attribute scrubbing and parent-based sampling, verified with one end-to-end trace.

opentelemetry 244 lines
★ No. 166

Prometheus Alerting

Pages that mean act now, routed to one thread

Claude sorts signals into page, ticket or dashboard before writing a single rule, then builds recording rules, symptom-based alerts with for durations, minimum-traffic guards, severity labels and runbook links. Rules are unit tested with promtool and checked by a bundled linter, and Alertmanager gets grouping and inhibition so one outage sends one notification.

prometheus-alerting 249 lines · 2 files
No. 167

Pulumi IaC

Real code for infra, with previews you actually read

Claude structures Pulumi projects by lifecycle, keeps secrets in encrypted config or ESC, and wraps reusable infrastructure in ComponentResources with stable type tokens. It handles Outputs without string bugs, adds aliases before renaming anything, protects stateful resources, and reads every preview for replaces and deletes before asking you to approve an update.

pulumi-iac 230 lines
No. 168

SLOs and Error Budgets

Page when the budget burns, not when a graph wiggles

Claude defines SLIs as good over valid events measured near the user, picks targets from past performance, and uses a bundled calculator to derive the budget and the 14.4x, 6x and 1x burn-rate thresholds. It writes Prometheus recording and alerting rules, backtests them against past incidents, and drafts the policy that governs releases when the budget runs low.

slo-error-budgets 193 lines · 2 files
No. 169

systemd Services

Units that restart sanely and run sandboxed

Claude writes units with the right Type=, foreground ExecStart, restart backoff and start limits, and puts changes in drop-ins instead of vendor files. It replaces cron and nohup with timers and services, keeps secrets in credentials rather than unit files, and hardens each service directive by directive until systemd-analyze security reports a low exposure score.

systemd-services 264 lines · 2 files
No. 170

Terraform IaC

Read the plan before the plan reads you

Claude structures Terraform or OpenTofu code as per-environment roots over typed modules, pins providers, and keeps state remote and locked. Every change goes through fmt, validate, tflint and a saved plan that a bundled script summarizes, flagging replacements of databases and buckets. Renames use moved blocks and adoptions use import blocks, and nothing is applied without approval.

terraform-iac 222 lines · 2 files

Choosing DevOps & SRE skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with GitHub Actions and Prometheus Alerting. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Install Claude Code Skills (5 Ways) and Personal vs Project Skills.

By technology: Kubernetes skillsDocker skillsTerraform and IaC skillsAWS skills

Install several

Install several at once

The installer accepts any number of skill names. Add --project to install into the current repository.

curl -fsSL https://claudeskills.page/install.sh | sh -s -- ansible-playbooks argocd-gitops blue-green-deploys chaos-engineering ci-pipeline-speed dns-tls-certificates docker-compose dockerfile-optimization github-actions gitlab-ci grafana-dashboards helm-charts incident-response kubernetes-autoscaling kubernetes-deploy linux-troubleshooting log-analysis nginx-reverse-proxy nix-environments opentelemetry prometheus-alerting pulumi-iac slo-error-budgets systemd-services terraform-iac

DevOps & SRE skills FAQ

How do I install every DevOps & SRE skill at once?

Download the bundle at https://claudeskills.page/downloads/category/devops.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- ansible-playbooks argocd-gitops blue-green-deploys.

Will installing 25 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which DevOps & SRE skill should I start with?

Start with GitHub Actions, Prometheus Alerting. They cover the most common requests in this category; add the rest as your work calls for them.

Featured in Production Backend, Ship to Production, Cloud Native Ops.

Explore other categories

esc