PODCAST EPISODE 132

Paul Stack: I'll Never Write Infrastructure as Code Again

Paul Stack helped build Terraform. Now he'll never write infrastructure as code again, and explains the agent harness running Swamp's production in its place.

17 Nov 202601 h 02 minwith Paul Stack

Transcript

In this episode

Paul Stack helped build Terraform. Now he says he'll never write another line of infrastructure as code, because an agent harness runs his team's production infrastructure instead.

Watch all the AI DevCon NYC 2026 talks:
https://tessl.co/kpo

Recorded live at AI DevCon NYC 2026, Guy Podjarny sits down with Paul, who spent years on Terraform at HashiCorp and on Pulumi before Swamp, to unpack why agents still trip over infrastructure state, what it takes to run a software factory that automates software delivery all the way to production, and why the people who know the system still make the calls. Then stay for Paul's full DevCon talk, From Page to Dossier, on a lights-out factory that does the 3am on-call legwork before anyone is woken up.

What we cover:

  • Why agents still struggle with infrastructure as code, and why state is the hard part
  • Model problem or harness problem: what an agent harness for operations needs
  • Running an AI-first software factory from issue to production
  • Blast radius, deterministic workflows and keeping credentials away from agents
  • Why agents love toil, and why operators still own the judgment
  • Paul's AI DevCon talk: turning a 3am page into a ready-made dossier

Chapters:

00:00:00 - Introduction

00:02:21 - From Terraform and Pulumi to Swamp

00:04:19 - How good are agents at infrastructure as code?

00:07:28 - Model problem or agent harness problem?

00:09:54 - Do we still need infrastructure as code?

00:12:53 - Inside an AI-first software factory

00:15:34 - Blast radius, determinism and agent credentials

00:18:48 - Agents love toil: the ops harness engineer

00:21:49 - Why software factories need ops

00:27:35 - AI DevCon talk: From Page to Dossier

Book early for AI DevCon London 2027, 7–8 June at The Brewery, Moorgate:
https://tessl.co/wzi

🔔 Subscribe for weekly episodes on AI-native development

Would you trust an agent harness to run your production infrastructure, or does your team still want a human on every apply? Tell us in the comments.

Most of the attention in agentic development has gone to the path from ticket to pull request. As that path matures, the harder question appears to be what happens after the merge, and whether an agent harness can carry code safely into production. Infrastructure is where that question gets uncomfortable, because every line carries weight and every mistake has a blast radius.

Paul Stack has spent most of his career on that problem. He was early at HashiCorp, helped build a lot of what Terraform is today, spent four years at Pulumi, worked on System Initiative, and is now at Swamp, which treats agents as first-class citizens in managing infrastructure. Guy Podjarny sat down with him at AI DevCon NYC 2026, and the episode closes with Paul's full conference talk, From Page to Dossier.

Why agents still stumble on infrastructure as code

Paul's view is that models have improved markedly at infrastructure as code over the past six months, but the code itself is only part of the story. Real-world infrastructure code tends to be heavily opinionated, shaped by one team's taste, with modules stacked upon modules that are hard for an agent to reproduce faithfully.

"If you ask an agent to produce base vanilla infrastructure as code, no problem," he noted. The difficulty starts when existing code has to be refactored, because there is a layer of state underneath it. Resources already exist in the world, so an agent cannot simply try a pattern, observe the result and try again. The plan and apply loop is slow for humans, and slower still for agents, particularly while teams remain unsure whether agents should be allowed to run the apply at all.

What is an agent harness for operations?

An agent harness for operations is the machinery around the model that conveys the current state of production, encodes the exact workflow steps an agent is allowed to run, and controls access to credentials. It aims to give the agent enough context to act while keeping the riskiest steps deterministic rather than improvised.

In practice, Paul explained, very few teams write vanilla Terraform or Pulumi anyway. They already use tools that sit on top and provide their own abstractions, so bringing in agents often means rebuilding that harness for a new kind of user. At Swamp, the building blocks are behaviors: encoded pieces of intent with schemas, workflows and gates. "It is an actual agent harness that is doing it the whole way," he observed.

Two properties stood out. The first is determinism at the points that matter. The agent does not need to reason its way from here to production; it needs to run one specific, tested workflow step. The second is credential isolation. After a rough month for vulnerabilities, Paul argued that agents should never see raw keys or environment variables. The automation should pick up the secrets itself, so the agent only knows that a step can run, not what it runs with.

Do we still need infrastructure as code?

Guy pushed the conversation somewhere more contrarian. If human labor was expensive and error-prone, infrastructure as code made sense as an intermediate representation. If agent labor is cheap and can be nudged by a harness, what value does that layer still add?

Paul's answer was unambiguous. "For me, I'll never write another line of infrastructure as code," he said. Swamp has moved its own production infrastructure four times in six months, from Railway to DigitalOcean App Platform to DigitalOcean Kubernetes to GCP, including full data migrations.

It can be helpful to think about this as a two-part model. On one side sits a map of the system as it exists today. On the other sits the intended state. A capable agent, given both, is effectively translating A to B. Infrastructure as code adds a third layer between them, which Paul has previously called the 200% problem: you need to know both the cloud provider's SDK and the abstraction on top of it. Agents, he pointed out, do not care about that layer.

The software factory is more than software

Paul describes Swamp as AI-first. No systems or servers are configured by hand. When an issue is picked up, Paul explained, the company's software factory runs the whole way through, including a test factory and a release factory, all the way to production, handling deployments and load balancer changes along the way.

Interestingly, Paul pushed back on the term itself. He suggested "software factory" can be misleading, because the hard part is not the code but how that code gets into production and runs there. The closer infrastructure management sits to the software, the less context gets lost in hand-offs between dev and ops teams. Guy observed, with some amusement, that achieving true DevOps may have required taking the human out of the equation.

Paul also connected this to delivery maturity. In his experience, the teams getting the most out of agents today appear to be the ones furthest along their journey to continuous delivery. Teams that already have the processes and workflows in place for shipping can apply them to agents and see a much smoother transition.

Agents love toil, operators keep the judgment

The most practical part of the conversation was about toil. "Agents are not bored by toil. Agents love toil," Paul noted. They will run the same mundane checks again and again without cutting corners, which is exactly where humans struggle at 3am.

His talk turns that into a concrete system. Swamp built what Paul calls a lights-out factory for alerts. An alert arrives, is verified, deduplicated and correlated, then screened by a small decision model before anything expensive runs. Swapping that screening step from a frontier model to a decision model called Jev cut the pipeline's costs by 91%. Crucially, alerts are closed by deterministic code written to the organization's business rules, and the only call the agent makes on its own is whether an incident is a duplicate. Only after the whole tree has run does a human get paged, and they arrive with a structured dossier rather than a blank terminal.

The framing that ties it together is a distinction between lights-on and lights-out factories. Lights-out suits work where the steps are known and repeatable. Lights-on keeps a human involved wherever judgment and taste matter. On root cause, Paul was explicit: the agent offers hints about where to look. "It's evidence. It's not a conclusion."

That suggests a role shift rather than a replacement. Paul sees the operator becoming something like an ops harness engineer, embedding their system knowledge into the harness so that agents act as a force multiplier.

Whether your team is ready to let an agent run a cloud migration, or would rather start by letting one write the 3am briefing, the episode is worth a listen, and Paul's full DevCon talk is included at the end. Which part of your operations would you hand over first?

CHAPTERS