CUE, Kyaml, and the Battle to Fix YAML: Devs Are Over It

YAML might still be the default in Kubernetes land, but among engineers in the trenches, there's a clear vibe shift: the love affair is over. Sure, YAML files are everywhere, from deployments to secrets to CI/CD pipelines. But behind that calm, indentation-sensitive surface, there's growing frustration. It's brittle, unpredictable, and in complex systems, downright risky.

The good news is that a wave of tools is trying to fix YAML without throwing it out completely. CUE, Kyaml, Jsonnet, and a rising number of alternatives aim to give developers some much-needed breathing room.

YAML: the necessary evil

Ask any DevOps engineer, and they'll tell you: YAML doesn't run the infrastructure, but it sure does configure most of it. From Kubernetes manifests to GitHub Actions, YAML has become the universal duct tape of declarative configuration, and it wasn't built for this scale.

The format is whitespace sensitive, so miss one indentation and you're in debugging trouble. It lacks native validation or type checking, which means you won't know about that typo in your config until something breaks. It isn't DRY either: repetition is everywhere, and reusing config is a matter of luck. And it isn't modular, so splitting logic across services or environments becomes a patchwork of scripts, templates, and wishful thinking.

For teams managing dozens of microservices across multiple environments, these are systemic headaches rather than minor annoyances.

The CUE revolution: structured, validated, and actually usable

CUE (short for Configure, Unify, Execute) is a whole new paradigm rather than an attempt at YAML 2.0. Think of it as a superset of declarative configuration that treats YAML like a second-class citizen (in a good way).

One developer in the thread put it bluntly: "Being able to just change one file to update config for a whole load of services, with minimal side effects, all tested, has completely changed my life."

Here's what CUE brings to the table:

• Built-in validation. You define schemas and values together, with no separate linter or pipeline step needed.
• Modular config. You can combine configs across files and directories without hacks.
• Type-safe transformations. It generates YAML or JSON reliably, so no more broken outputs.
• Integrated testing. You can compile your configs and validate them before they even hit a cluster.

Oh, and it's fast. Really fast. Teams using CUE in production say they've massively reduced config bugs and regained their sanity.

Kyaml: YAML, but cleaner (sort of)

If CUE is the bold new world, Kyaml is the minimalist trying to make YAML suck less. It wraps YAML in a structure that's actually maintainable, adding structured comments, programmatic edits, and schema-aware validation.

Essentially, Kyaml keeps the YAML syntax but adds tooling so it doesn't feel like writing code in a landmine field. For devs who want to stay close to the Kubernetes native ecosystem, it plays nicely with Kustomize and other CNCF tools.

That said, some engineers remain skeptical: "Just JSON in YAML syntax," as one user put it. Their view is that if you're going to reinvent YAML, you might as well replace it.

Jsonnet, Dhall, KDL, and the no-YAML movement

Some devs aren't interested in fixes at all. They want out, and they're turning to tools like:

• Jsonnet: think of it as JSON with functions, conditionals, and inheritance. Many teams use it to generate YAML templates cleanly.
• Dhall: a total rethink of configuration that is typed, programmable, and strongly validated.
• KDL (KDL.dev): a new structured markup that reads more like Markdown and less like XML or YAML. It's clean, readable, and modern.
• NoYAML: yes, it's a real site, and the name kind of says it all.

What these tools offer above all else is structure. YAML was built to be human-readable, but at scale, human-readable quickly turns into human-error-prone.

GitHub Actions, CloudFormation, and the worst offenders

Developers weren't shy about calling out specific tools that've pushed YAML to its limit.

"The people who designed GitHub Actions certainly seem to think YAML is a programming language."

"Looking at you, CloudFormation."

These tools use YAML for everything from conditionals to loops to variable substitution, none of which YAML was designed to do. It becomes a sort of pseudo-programming language without the benefits of actual programming languages like linting, typing, or composability. It's no surprise that infrastructure engineers are pushing back.

AI and YAML: a love-hate relationship

One unexpected twist is that AI models, including GPT-based tools, are surprisingly good at generating YAML. Once you understand YAML's structure, it's extremely pattern-based.

In fact, one developer noted that adding compilation steps (via CUE or similar) makes AI-generated configs more reliable than hand-written ones in some environments. With proper schemas and validation layers, AI becomes less of a risk and more of a collaborator.

YAML still doesn't get a free pass, but the next phase of config tooling will likely have AI in the loop, whether we like it or not.

So... is YAML dead?

Not yet. For better or worse, YAML is still everywhere. It's baked into CI/CD pipelines, Terraform wrappers, Kubernetes CRDs, Helm charts, and more, and replacing it won't be easy.

The growing dissatisfaction is real, though. The tooling to escape it, or at least manage it better, is here and getting more powerful every month. CUE, Kyaml, Jsonnet, and Dhall have moved past fringe status and become survival kits for modern infrastructure.

YAML isn't going away tomorrow. But if you're building or maintaining complex systems, you've got better options now, ones that treat your config as code worth engineering well instead of a side project.

And if YAML wants to stay in the game, it's got some growing up to do.