Someone types “scale the payments cluster to twelve nodes and open the firewall for the new region” into a chat box, and ninety seconds later it is done. No ticket. No pull request. No diff anyone read. It feels like the future, and in one narrow sense it is. It is also the cloud console with a chat box bolted on, and it just walked around every artifact the industry spent fifteen years making mandatory.

That is the part the word “VibeOps” keeps hiding. Vibe coding, the term Andrej Karpathy coined in early 2025, is a fair name for turning an idea into a diff and barely looking at the code. VibeOps is what people now call doing the same thing on the other side of the diff: deployments, incident response, infrastructure changes, cost fixes, all driven by natural language instead of manual toil. The problem is that it staples two very different jobs together and hopes you will not notice the seam.

Two jobs we keep calling one

Building infrastructure and operating it are not the same activity, and they never were.

Building is delivery. It is the act of bringing a new system into existence: a cluster, a network, a data pipeline, the permissions around them. Delivery has a right answer to the question “what does good look like,” and that answer is a reviewed, versioned artifact.

Operating is everything after the system is live. A pager fires at 2am. A config drifts. A cost anomaly spikes. Someone needs to reach into the running platform, understand what is happening, and act. Operating has always needed a direct, immediate interface to the platform, and for twenty years that interface was a console you clicked through.

VibeOps, as it is usually sold, blurs these into one undifferentiated “let the agent run your systems.” Pull them back apart and the useful advice falls out cleanly. Do not vibe the building. Do rethink the operating.

What IaC actually bought us

Before infrastructure as code, operating the cloud meant clicking through a portal. It was intuitive and completely unaccountable. Every click was a human reading a screen and making a decision that left no record anyone else could reconstruct. The 2am change that broke production on Tuesday was, by Thursday, a thing nobody could reproduce or even prove had happened.

Infrastructure as code was the correction, and it was a good one. You declare the desired state, you put it in version control, someone reviews the change, and the system reconciles reality to match. That loop is older than the cloud, as I argued in The Reconciliation Loop, but IaC made it the default. What you bought with it was reproducibility, an audit trail, and a human who read the diff before it shipped. The discipline was the product. The Terraform was how you wrote it down.

The catch, and it is a real one, is that IaC put a tax on speed and a floor on expertise. Writing good modules is a skill. Reviewing them is a skill. Plenty of teams have a mountain of Terraform they cannot confidently change, which is its own failure mode. I have written before about the gap between AI writing the code and an organization being able to ship it in AI Can Write Your Terraform. Can Your Organization Deploy It? The discipline is expensive. That expense is exactly what makes the chat box so tempting.

The chat is the new console

Here is the concession, and it is a genuine one. Operations really does need a direct line into the running platform, and the console was always a clumsy way to provide it. Clicking through six screens to correlate an alert with a deploy and a cost spike is not a sacred ritual. It is toil. If the new interface for that toil is a conversation instead of a maze of tabs, that is progress.

This is the legitimate core of VibeOps, and the serious vendors describe it carefully. Datadog, in its DASH 2026 announcements, frames it as agent-assisted operations: AI agents grounded in telemetry, context, permissions, memory, and guardrails, operating inside defined workflows with human approval where it matters. That is not “let the AI run wild.” That is the console, made conversational, with the accountability wired back in.

Picture the loop concretely, because abstraction is where this gets oversold. An alert fires. An agent reads the logs, traces a crashing service back to a specific configuration change, and either proposes the fix or, for a low-risk class of action, applies it and tells you. That is a real, useful interaction. It is the console answering back. The question is not whether that should exist. It should. The question is what it leaves behind.

Vibing the build is the mistake

Where this goes wrong is when the chat box stops being a console for operating what exists and becomes a shortcut for building what does not. Someone describes a new piece of infrastructure, an agent conjures it into production, and no reviewed artifact is ever created. That is not VibeOps. That is ClickOps at machine speed: the same ephemeral, unaccountable point-and-click, except now it happens hundreds of times a minute and there is no screen a human even glanced at.

The safety margin in the old world was implicit. It was slow enough that a person read every line. Remove the person and you have to replace the margin with something, or you are just shipping unread changes faster. And the unread changes are not safe. Veracode’s 2025 GenAI Code Security Report found that when models had a choice between a secure and an insecure way to write something, they chose the insecure one about 45 percent of the time, and produced roughly 2.74 times more vulnerabilities than human-written code across the tasks tested. That is not a reason to stop using agents. It is a reason to never let their output reach production unread.

The failure modes compound from there. Slopsquatting, where attackers pre-register the fake package names models tend to hallucinate, turns a confident wrong import into a supply-chain compromise, which is why prompt injection and its cousins sit at the top of the OWASP LLM risk list. Secrets get hardcoded and committed, a problem GitGuardian keeps documenting at scale and one that is worse inside private repos than public ones. And a whole population of non-experts can now ship infrastructure nobody is monitoring, which is Shadow IT with a bigger engine. None of this is exotic. It is the ordinary cost of removing review, arriving faster than a human can catch it. Automating a broken process does not fix it, as I put it in Automating Chaos Produces Automated Chaos. It produces broken outcomes at scale.

Make the chat produce an artifact

The fix is not to ban the chat. It is to insist that everything it does lands as something you can review.

An agent action should not evaporate the way a console click did. It should produce an artifact: a pull request for an infrastructure change, a written plan for a remediation, a signed receipt for an executed action, all of it in version control and all of it attributable to both the human who asked and the agent that acted. That is the discipline IaC taught delivery, applied to operations. The chat becomes a faster way to author the artifact, not a way to skip it.

Around that sits a guardrail with a dial, not a switch. Some actions the agent should simply notify you about after the fact. Some it should stage and hold for review. A few, the reversible and low-value ones, it can take autonomously. Which bucket an action falls into is a policy decision the platform enforces below the chat, never a suggestion in the prompt, because anything a reword can bypass is decoration, not a control. The human governs the agent and reviews its artifacts. The human does not babysit the console. That distinction, the gate built for the actor rather than for the click, is the one I keep circling back to in The Gate Was Built for a Human.

This is also the honest answer to why the chat is not just a nicer console. A nicer console still leaves nothing behind. A chat that emits a reviewable artifact is strictly better than the point-and-click it replaces, because the old console never gave you the diff at all.

Where the human keeps clicking approve

There is a tier of work where the dial stays pinned to “review,” and it is worth naming plainly. Payments. Anything touching health data. Authentication and identity. Systems under PCI DSS, HIPAA, or equivalent regimes. Critical infrastructure. In those domains the answer to “can the agent just do it” is no, not because the agent is useless there, but because the accountability requirement is external and non-negotiable. Someone has to sign their name, and a signature means a human took responsibility for a change they understood.

That is not Luddism. It is the same logic that keeps a second set of eyes on a wire transfer. The value of the agent in those domains is that it drafts, investigates, and explains at speed. The value of the human is that they remain the accountable party. Vibing is fine for a staging environment you can throw away. It is malpractice for a system where the failure mode is regulatory or financial harm to real people.

What I’m still figuring out

I want to be honest about the soft spots in my own position, because this space is moving monthly and certainty would be a tell.

The artifact discipline I am describing is more aspiration than reality in most of today’s tooling. A lot of agent actions still evaporate the moment they run, and retrofitting a reviewable-artifact requirement onto a chat interface is real engineering work that few products have finished. The agentic development lifecycle for infrastructure, the disciplined path I would push people toward for building, is young and still mostly convention rather than tooling. And the clean line I drew between building and operating blurs in practice, because a big enough operational change is a build in everything but name. The framework holds. The edges are genuinely fuzzy, and anyone selling you a fully autonomous version of this today is selling you the 45 percent.

So do not vibe your infrastructure. Build it as an artifact you can review, through a lifecycle that expects one. Let the chat be the new console for operating what is already built, held to the same accountability the old console never had. Intent has never been the scarce thing. The artifact is where the accountability lives, and that is the part worth keeping.

---

If this resonated, read AI Can Write Your Terraform. Can Your Organization Deploy It?, on the gap between generating infrastructure and shipping it, and You’re Renting the Model. Own the Harness., on why the durable asset is the control layer you build, not the model you rent.

Find me on X @orestesgarcia or LinkedIn /in/setsero.