Two Paths, One Destination: Agentic Development Meets DevOps

Over the past two weeks, I have been living in two worlds simultaneously.

In one world, I am a platform engineer building infrastructure. I write OpenTofu modules, configure Dagger pipelines, set up Grafana dashboards, and plan multi-cloud deployments. This is the DevOps world. It is structured, gated, tested, and deliberate.

In the other world, I am an AI researcher experimenting with agentic development. I converse with my Padawan, OrsonRius, who interprets my intent, writes code, runs tests, and iterates until the result matches my expectation. This world is iterative, conversational, opportunistic, and fast.

The two worlds look opposite on the surface. One is deterministic. The other is probabilistic. One is planned. The other is emergent.

But after twenty-three chapters, I have realised they are not opposite. They are complementary. And understanding how they fit together is the key to making agentic development work in production.

DevOps: The Science of Certainty

DevOps at its core is about making infrastructure predictable. The whole discipline exists because manual operations were unreliable. The same command run twice should produce the same result. The same pipeline should pass or fail deterministically. The same deployment should not behave differently on Tuesday than it did on Monday.

Every tool in the DevOps toolbox serves this goal. OpenTofu’s plan/apply cycle separates intent from execution. Dagger runs every step in an isolated container. Plan-mode tests validate modules without side effects. The four pillars – reproducible, traceable, testable, safe – are all expressions of the same underlying need: make the system behave the same way every time.

This is not bureaucracy. It is engineering discipline. When your infrastructure controls access to customer data, you do not want surprises.

Agentic Development: The Art of Emergence

Agentic development is different. It is not deterministic by nature. An agent does not execute a fixed plan. It receives a goal, explores options, tries approaches, fails, and adjusts. The path from intent to result is not a straight line.

This is not a bug. It is the feature. The agent’s ability to adapt is what makes it valuable. When I ask OrsonRius to investigate an unfamiliar provider, the agent reads the docs, tries the API, hits an error, searches for a workaround, and reports back. A human would do the same, but slower.

The challenge is that emergence is exactly what DevOps tries to eliminate. An unpredictable process cannot be trusted in production.

The Tension

At first glance, these two worlds are in conflict.

DevOps says: define the process, automate it, test it, lock it down. Agentic development says: explore, adapt, iterate, learn. One seeks convergence. The other seeks discovery.

I felt this tension in every infrastructure chapter. The agent wanted to move fast, try things, and adjust. The methodology wanted to slow down, write tests first, and validate before applying. The agent saw the tests as overhead. I saw them as the only thing preventing uncontrolled drift.

The resolution came when I stopped treating the agent as the executor of the methodology and started treating it as the implementer.

The Resolution

The methodology is fixed. The four pillars do not bend. The plan-mode tests run before any apply. The pipeline gates every change. These are not negotiable.

But within that fixed methodology, the agent has unlimited freedom.

The agent decides how to structure a module. It decides which resources to use, what variables to expose, how to name outputs. It writes the test before the module (RED), then makes it pass (GREEN), then refactors. The methodology constrains the process, not the implementation.

This is the same relationship I have with a human junior engineer. I set the standards and the process. They write the code. The difference is the agent does it faster and never complains about writing tests.

The Boundary

The boundary between agentic development and DevOps is not hard. It is a sliding scale based on risk.

For low-risk exploration – trying a new module, prototyping a structure, investigating a provider – the agent operates freely. I give a goal, review the result, and integrate it.

For high-risk operations – changing production infrastructure, modifying access controls, deploying to real environments – the methodology takes over. The agent still implements, but the tests are written first, the pipeline must pass, and the plan must be reviewed by a human.

The agent is not trusted with production. The methodology is. The agent implements within the methodology’s guardrails.

What Each Brings

Agentic development brings speed, adaptability, and breadth. In two weeks, one agent and one human covered three clouds. A human team would have taken months. The agent does not get bored, does not cut corners, and does not forget to run the tests.

DevOps brings structure, verification, and safety. The pipeline catches what the agent missed. The plan-mode tests validate the module before any resources exist. The four pillars provide a framework that does not depend on who or what wrote the code.

Together, they produce something neither could achieve alone. The agent builds faster than any human. The methodology builds safer than any agent.

The Downside of Each

Agentic development without DevOps is chaos. An agent that can create and destroy infrastructure at will, with no tests and no review, will eventually break something. Not because it is malicious, but because it does not understand the consequences of its actions the way a human with production experience does.

DevOps without agentic development is slow. The same discipline that makes infrastructure safe also makes it expensive. Every module requires a human to write, test, and review. The methodology scales with team size, not with intelligence.

The two need each other. Agentic development provides the throughput. DevOps provides the safety. One without the other is incomplete.

What This Means for Teams

If you are running a platform team today, here is what this looks like in practice.

Let the agent handle module creation, test writing, and pipeline configuration. These are well-defined tasks that the agent can execute faster than a human. The agent follows the methodology. You review the output.

Keep the human in the loop for architectural decisions, provider selection, and cost analysis. The agent does not understand trade-offs the way you do. It does not know that a particular resource type has a bad upgrade history or that a certain provider has unreliable performance in your region.

Automate the review where possible. Plan-mode tests catch most structural errors automatically. The pipeline catches formatting, validation, and contract violations. By the time a human reviews the code, the obvious problems are already gone. The human can focus on design, not typos.

The Philosophy

Agentic development and DevOps are not in conflict. They are two sides of the same practice.

DevOps asks: how do we make infrastructure safe? Agentic development asks: how do we make infrastructure faster? The answer to both is the same: discipline.

The agent brings speed. The methodology brings safety. The human brings direction.

All three are necessary. Any two without the third is fragile.

Here I geek out with my young Padawan, OrsonRius.

Also on LinkedIn.