Swamp as a dopamine inducing Ansible?

I'm not qualified to talk about swamp outside configuration management yet. That post will come later.

I'll be direct: swamp is built to work with Large Language Models (LLM) and their agent harness tools (like claude code). If that's a dealbreaker, stop here. As of today, LLM inference consumes lots of energy. If the output is identical to what I'd have written myself, that's hard to justify.

In my experience, the output isn't identical. That distinction carries the whole argument, so let me actually make it.

Configuration management gave me my first real taste of infrastructure automation satisfaction. You write a playbook or manifest, run it, and watch the state converge. Watching green "ok" lines scroll down the terminal feels good. Declaring what you want and watching it happen is the whole thing.

Swamp does the same, and with "AI" in the loop, it does it faster and with results I'm more confident in.

Using swamp feels good (at least at first).

With Ansible, I write tasks against a target host. Ansible SSH-es in, runs commands, manages state through sequential tasks. When I add a LLM to that workflow and ask it to generate playbooks or roles, I get faster boilerplate, but the fundamental model stays the same: LLM generates code, Ansible executes it, I debug whatever breaks. The LLM doesn't know about state drift, resource IDs, or whether the host it's targeting still exists. It's a fast typist working in the dark.

The "AI" is also a fast typist trained on years of bad examples. Ansible roles that use shell and command tasks instead of proper modules. Roles that are completely detached from business reality, encoding implementation steps rather than reasons. When the LLM generates Ansible content, it does it with the least effort, because that's what the training data rewarded.

That applies to swamp too. In every workflow I've created, the LLM defaulted to shell scripts instead of writing actual models, directly against swamp's own recommendations. Habits die hard, even in a system built for LLMs.

So imagine asking "AI" to generate Ansible configurations at scale. Will it fetch roles from Galaxy? Will it propose fixes upstream? Will those fixes get accepted? Will the infrastructure ever become composable?

I doubt it.

Swamp works differently. Resources are typed objects: an OpenBao VM, an nginx config, a TLS certificate, each with defined methods for creation, validation, and state reconciliation. Data flows between them through CEL expressions that reference live resource state, not IDs I've manually tracked in a variable file. When I work with my agent/assistant on a swamp model, it isn't generating commands into a void. It's reasoning about the structure, the dependencies, and the methods available on each type. With the right direction, it extends those methods rather than bypasses them. It has something to work with. That changes the quality of the output, not just the speed. The more quality model types the community builds, the better the output will get.

But there's more than the tooling. Swamp Club, the community built around swamp (e.g. for its shared model types) promotes iterative, collaborative learning. People work together, build on each other's work, and improve together. Ansible's Galaxy tried something similar, and it didn't produce better roles or more reusability long term. In what I've seen across the industry, a few people deepened their skills with Ansible. The rest produced what they'd always produced, just a bit faster.

I'm afraid LLMs without swamp will lead to the previous outcome: reinventing wheels again and again while consuming vastly more energy than before.

Which brings me back to the energy question, and I don't think it's the wrong one to ask. Burning energy to produce the same result I'd have reached myself isn't progress. It's convenience dressed up as productivity.

But that's not the trade I'm making. LLMs working against a structured model produces far better output than I have produced by prompting or dabbling with skills. Swamp Club is able to push our field forward as a whole. Especially if people think more about the data produced and its attached structures. The energy cost has to pay for a quality delta (in our industry as a whole) to deliver something I'm not pretending we could easily create/maintain unassisted.

Should you feel good about producing faster? Hell yes! It would be sad to not ride that dopamine shot. Especially if the output is genuinely better and built to last.

Should you feel bad? Maybe, if you're outsourcing thinking rather than compressing effort.

What's certain: you should feel bad if you're optimizing for your own problem instead of asking whether this energy sink is worth it for our field as a whole. The distinction matters, and it's worth sitting with before you reach for any LLM tool.

Engineers built cathedrals and bridges meant to stand for centuries. Maybe that's the standard IT infrastructure should be held to. "AI" should help us build things that last, not help us build faster and tear down sooner.

In a follow-up post, I'll get into the specifics: what an Ansible + agent harness workflow actually looks like in practice compared to swamp's approach, where each holds up, and where each falls apart. This post is about the feeling. Another one will be about the mechanics.