Un-mastering DevOps: what three years and a few thousand agents did to my 2023 advice

In May 2023 I published a post called "Mastering DevOps: Tips and Tricks for a Seamless Software Development Workflow." I described DevOps teams as superhero squads. I used the phrase "magical world of DevOps" without irony. I listed tools, told you to start small, and wrapped it up with success stories about Etsy and Target.

Here's the strange part: almost everything in that post is still technically true. CI/CD is still how you ship. IaC is still how you manage infrastructure. Observability still saves you at 3am. And yet the job I described is unrecognizable, because the newest member of the team isn't human.

This is the revisit. Three years, one AI wave, and a loft of production incidents later.

The part where the demos became the day job

In 2023, "AI in DevOps" meant a chatbot that could explain a Kubernetes error message. Cute, occasionally useful, not an operating model.

In 2026 it looks like this: an alert fires, and before a human opens the dashboard, an agent has already read the alert, pulled the relevant logs, correlated it with last night's deploy, and posted a proposed root cause with a runbook link. For a routine fix, it has a PR open. For a config drift, it has the diff ready. Our engineers at Quintessential increasingly start incidents by reviewing an agent's triage instead of doing the triage.

This isn't us being clever. The cloud vendors made it first-party. AWS shipped DevOps and Security agents into general availability. Microsoft's Azure SRE Agent went GA in March 2026, and Microsoft says it runs more than 1,300 agents internally that have mitigated tens of thousands of incidents. GitHub Copilot grew custom agents you can point at your platform workflows.

When the vendors are betting their own on-call rotation on it, the demo era is over. The question is no longer "does this work" but "how do we operate with these things safely."

Agents now do real DevOps work: incident triage, routine-fix PRs, drafting pipelines, writing and reviewing infrastructure code. Not all of it well, not all of it unsupervised. But real work, in production, every day.

IaC turned out to be the agent's native language

My 2023 post listed Terraform, Pulumi, Ansible, and Chef and told you IaC was worth the learning curve. What I didn't know was that we'd all spent a decade accidentally building the perfect interface for machine coworkers.

Think about what declarative IaC gives you: code that describes intent, a plan/preview step that shows exactly what will change, state that tracks reality, version control, and rollback. That was always the right abstraction for humans. It turns out it's exactly what you want when the author is an agent. Reviewable diffs. Dry runs. An audit trail by construction.

The tooling caught up fast. There are MCP servers for Terraform that give agents registry intelligence, for Ansible, and for Pulumi, whose Neo agent takes delegated infrastructure tasks. Pulumi reports that around a fifth of operations on their platform are now agent-driven. That number will only go in one direction.

The practical effect: the barrier to entry for IaC collapsed. You no longer need to memorize HCL syntax or the exact shape of an aws_iam_role_policy_attachment. You describe what you want, the agent writes it, and you review the plan. Every small team that told me "IaC is too much overhead for us" just lost their excuse.

If you're still clicking around a cloud console in 2026, that's a choice, not a constraint.

But here's the part people get wrong. The lesson is not "let the agent apply." The plan/apply review gate matters more now, not less. The value is compressed authoring with human judgment at the gate. An agent writing Terraform in thirty seconds is great. An agent applying Terraform without a human reading the plan is how you end up explaining to a client why their database is gone.

The uncomfortable section: what agent access to prod actually means

This is the part of the post I'd want my 2023 self to read twice, because it's where the industry is currently making its mistakes.

An agent that touches infrastructure is a non-human identity. Treat it exactly like you'd treat a new privileged service account, because that's what it is:

• Its own identity. Never a shared credential, never a human's token.
• Least-privilege, scoped credentials. Access to what it needs for its job, nothing else.
• Time-bounded tokens. Not a static key created in 2024 that nobody remembers.
• Tool allowlists. An explicit list of what it may call, not a wildcard.
• A full audit trail. Every action attributable, every session reconstructable.

Now the sober part: most organizations are nowhere near this. Human IAM gets quarterly reviews, offboarding checklists, MFA. Non-human identities get created in a hurry, over-privileged "to make it work," never rotated, and never monitored. Very few orgs can tell you today what their service accounts can actually do. And we're now handing that same messy category of identity to software that takes initiative.

The patterns that work, in my experience running this for clients:

1. Gateway-mediated access. The agent doesn't talk to prod. It talks to a broker that enforces policy, scopes what it can see, and logs everything. If the agent is compromised or just confused, the gateway is your control point.
2. Read-only by default. Triage, log analysis, drift detection, cost review: enormous value, zero write access. Start here. Most teams should stay here longer than they want to.
3. Writes only through PRs. If the agent wants to change something, it opens a pull request. That's it. No direct kubectl, no console access, no "just this once."
4. Human approval for prod mutations. Anything that changes production state gets a human sign-off. Not a rubber stamp in a Slack thread; an actual review of an actual diff.
5. Blast-radius limits. The agent can restart a pod. It cannot delete a namespace. It can scale a deployment within bounds. It cannot touch the state backend. Design the ceiling before the incident, not after.

Notice what quietly happened here: GitOps became the safety layer for agents. We adopted Argo CD and Flux because we wanted deployments to be declarative and auditable. But if the only way to change production is a merged pull request, then agent access reduces to PR access, and the review machinery you already have becomes the guardrail. The 2023 post pitched GitOps as a convenience. In 2026 it's the containment strategy.

And since this section is supposed to be the sober one: the failure mode is not rogue AI. Nobody's agent is going to develop opinions and seize the cluster. The failure mode is a human wiring an over-privileged agent into prod on a Friday, skipping the guardrails because the demo went well, and then acting surprised on Saturday. The threat model is us, moving fast. Same as it ever was.

What my 2023 self got right

Rereading the old post, the fundamentals aged fine. Embarrassing metaphors aside, the skeleton holds:

• CI/CD as the backbone: still true.
• IaC as the way to manage infrastructure: more true than I knew.
• Observability as non-negotiable: still true, and now agents are the heaviest readers of your metrics.
• Culture of collaboration over tools: still the actual differentiator.

The tools mostly survived too. Argo CD went from "one of the CD options" to the de facto GitOps standard. Prometheus and Grafana are still everywhere. Terraform and Pulumi are still the IaC mainstays. GitHub Actions ate more of the CI market. Nothing on my 2023 list died of AI; the tools didn't change nearly as much as who operates them.

Platform engineering, which I mentioned in 2023 as the shiny new term, stopped being a buzzword and became how this actually gets structured. Most industry surveys now put platform teams in the large majority of software organizations. That matters for the agent story: the platform team is the natural owner of agent identity, agent guardrails, and the golden paths agents follow. If nobody owns the paved road, agents will drive off it.

Even the soft advice held up. "Start small, foster collaboration, invest in training" applies word for word to agent adoption. Just aim it at a new target.

The real role shift is this: engineers went from operators of tasks to supervisors of systems. Less typing kubectl, more reviewing what the thing that types kubectl proposes. Judgment moved up a level. It didn't become optional.

The 2023 practices list, revised

The old post had a tidy list of practices with tool recommendations. Here's the same list, three years on. Consider it a diff.

Continuous Integration.Then: pick GitHub Actions, GitLab, Jenkins, or CircleCI and automate your builds. Now: same platforms, but agents draft the pipelines, fix the flaky test, and open the PR that bumps the broken dependency. You review the workflow file instead of writing it from a blank page.

Continuous Delivery.Then: Argo CD or Flux, deploy from Git. Now: Argo CD won, and GitOps doubled as your agent guardrail. The merge gate is the point.

Infrastructure as Code.Then: learn Terraform or Pulumi, accept the learning curve. Now: describe intent, review the plan the agent wrote. The learning curve flattened; the review responsibility didn't.

Monitoring and logging.Then: Prometheus, Grafana, Loki, so humans can see what's happening. Now: same stack, but the first reader of your telemetry is an agent doing triage. Your dashboards are increasingly an API for machines and a verification layer for humans.

Collaboration tools.Then: Slack, Jira, Trello for the humans.Now: also where the agents report in. The incident channel has a new participant, and it types faster than you.

One new row that didn't exist in 2023: agent identity and access. Scoped credentials, allowlists, audit trails, offboarding. This is a first-class practice now, not an afterthought.

Marathon, still not a sprint

My 2023 conclusion said DevOps is a marathon, not a sprint. That advice stands untouched. Here's what I'd add for 2026:

• Give agents the boring work first. Triage, drift detection, log summarization, PR-shaped fixes. The work nobody fights over is where trust gets built cheaply.
• Keep humans at the merge gate. Compressed authoring, human judgment. That's the whole model. Don't let a good quarter of agent behavior talk you out of it.
• Treat agent identity as seriously as employee offboarding. If you can't answer "what can this agent touch and when did we last rotate its credentials," stop expanding its access until you can.

And a prediction, made with full knowledge of how this goes: I'll revisit this post in 2029, wince at something in it the way I now wince at "superhero squad," and write the next correction.

If the biggest problem with this post ages as well as the biggest problem with the last one, we'll be fine. The workflow still isn't seamless. But the seams are where the humans belong.