Agentic Devops with Claude Code

Most AI-for-DevOps material stops at "ask Claude to write the YAML." This course does not.

You build agents that do real operations work on a real, broken system — and the guardrails that make them safe to point at production.

The spine is Northstar Commerce. You join its platform team and inherit one flawed repository: two services, a fault-injectable upstream, a Terraform estate, Helm charts, CI, Prometheus and Alertmanager, open incident tickets, and scripts that inject faults and grade your work. Every module improves that same repo. Nothing here is a toy example.

What you build

• A triage agent that reads a live Kubernetes cluster, ranks five simultaneous faults by blast radius, and remediates through a second identity the first one structurally cannot use
• An IaC engineer that authors a Terraform module test-first and prices the change before it ships
• A release gate that decides whether a candidate ships, emits a schema-validated verdict your pipeline branches on, and holds no deploy authority at all
• An incident investigator that produces an evidence packet where every claim names the command that produced it — and declares what it did not check
• A four-role security team that ranks scanner findings by reachability instead of raw CVSS
• An always-on agent wired to a real Alertmanager alert

What you learn around them

The agents are the easy part. The operating layer is the course.

• Context as a budget, not a bucket — scoped instruction files, evidence contracts, bounded queries
• Model and effort as a staffing decision, with an OpenTelemetry run ledger to prove the bill
• Runbooks compiled into Agent Skills that a role can actually invoke — and tested against positive, negative and ambiguous cases
• Tool interfaces chosen deliberately: raw CLI, wrapper script, Skill or MCP server
• Hooks that enforce where a prompt only asks — and RBAC that still holds after you delete the hook
• Role-specific subagents with mechanically tested authority, and orchestration that does not collapse into three agents echoing one guess

How it is taught

Every module is a Lesson, a Lab, a Quiz, and a Deep Dive where the topic earns one. Labs are copy-runnable and validated live against the real stack before publish, so when a page shows you an output, that output is real — including the run that cost $0.34 and the ones that fail. Claims are measured, not asserted. Where a control does not actually hold, the course says so and shows you the measurement that proves it.

Every command runs on a Claude Pro or Max subscription. You do not need an Anthropic API key.

Who this is for

DevOps, SRE, platform, Kubernetes and DevSecOps engineers with working experience in Git, containers, CI/CD, Terraform and Kubernetes. Claude Code is taught from zero. The DevOps stack is not.

Early access

Every module is live now — from first principles through context and cost engineering, skills, hooks, subagents and orchestration, into Kubernetes triage, release engineering, incident response, agentic SecOps, always-on agents, agent evaluation and the capstone. Each one ships with video walkthroughs, a hands-on lab, a written deep dive and a knowledge check. Enrol now at the early-access price, and every future addition is yours as it ships.