The more I look at how we actually build systems now, the more it looks like Terraform is dead.

Not “declining.” Not “evolving.” Dead. What’s left is just inertia.

What Terraform Actually Solved

Terraform solved a very specific problem: how do we make infrastructure deterministic, reviewable, and repeatable?

The answer was a DSL, a plan step, and a state file. It worked, and it still works.

But it also forced an awkward compromise. Humans ended up describing intent in a language that was never designed to express it, and HCL is not how anyone actually thinks about systems.

How We Actually Design Systems

Think about how systems actually get designed.

Put a group of engineers in a room with a whiteboard and you don’t get HCL. You get boxes and arrows.

Someone sketches a service here, a database there, arrows showing flows, circles around “this must stay private,” and notes like “auth happens here” or “this needs to scale.”

Then the context gets filled in with words:

“This is the public edge.”
“This path needs stronger auth.”
“This data can’t leave the region.”

That combination of diagrams and natural language is the real design. It’s how we think, how we communicate, and how we reason about tradeoffs.

The design doc just formalizes it: diagrams plus explanation, intent plus constraints.

The Translation Problem

Terraform is not that. It’s the translation of that.

We take something that makes sense to humans and rewrite it into something a tool can execute. That translation step has always been the real work, even if we’ve treated the abstraction itself as the hard part.

The Hidden Cost: Fragmentation

Terraform didn’t just give us a DSL. It forced us to split a single system across multiple representations.

  • infrastructure lives in HCL
  • application logic lives in real code
  • policies are scattered across IAM, config, and application layers
  • diagrams exist as a rough approximation

All describing the same system, none of them truly in sync.

Those boundaries aren’t real. They’re artifacts of the tooling, and they show up as drift, duplication, and things that only exist in someone’s head.

AI Removes the Translation Layer

AI removes the need for that translation layer.

You can now start where we already start: a diagram, a paragraph, a set of constraints. Instead of expressing that through a DSL, the system works with you to turn it into something concrete.

If something is missing, it asks:

  • “Is this database public?”
  • “What availability do you need?”
  • “Should this be multi-region?”
  • “What are your retention requirements?”

Instead of encoding decisions indirectly in a DSL, you make them explicitly.

Where the Model Breaks

This is where the old model starts to break down.

If the interface to infrastructure is now diagrams, natural language, and iterative refinement, then a static DSL in the middle stops making sense.

You’re no longer writing infrastructure. You’re describing it the way you always have, just with a system that can carry that intent all the way through.

What I Would Build Instead

At that point, Terraform becomes something I wouldn’t choose.

If I were starting again today, I’d build an intent layer over infrastructure: diagrams, natural language, and constraints, backed by a system that interrogates and refines that intent, produces a canonical representation, and executes it using real code.

No HCL. No DSL in the middle.

If there’s something underneath, it looks more like Pulumi: general-purpose languages, testable, composable, and able to sit naturally alongside the rest of the system.

Conclusion

Terraform isn’t going away any time soon. Too much depends on it.

But the role it plays no longer makes sense.

It was designed as a human-readable abstraction over infrastructure, a way for us to describe systems in a structured, deterministic form that tools could execute.

That made sense when humans were responsible for bridging the gap between intent and implementation.

That constraint no longer exists.

We don’t need a better language to describe infrastructure. We need a system that can take intent and carry it all the way through to something that runs.

And once you have that, Terraform stops looking like a useful abstraction and starts looking like an extra layer you no longer need.