AI is fast. YAGNI is forever.

It’s easy to look at the new Artificial Intelligence coding agents and think we’ve just solved the problem of software development. Recent DORA study showed 90% of developers are using them so it’s hard to ignore.

We were always constrained by the cost and time it took a human to type. Now, that constraint is gone. The code, for all intents and purposes, is free.

So today I’m exploring whether we’ve just traded one scarcity for another.

For years, smart developers lived by five letters: YAGNI.

You Aren’t Gonna Need It.

It was a philosophy of restraint. Build what you need today, not what you might need tomorrow. Trust yourself to refactor later. Choose simplicity over speculation.

I still remember a prof at Acadia University saying “laziness is a virtue.”

YAGNI was the shield against feature creep and over-engineering.

AI doesn’t think like that. It can’t. Its reward structure optimizes for the next most probable token. It’s designed to be thorough, not minimal. It generates scaffolding, boilerplate, and multiple paths to the same solution. In its world, more equals better.

The conflict is stark: AI prioritizes abundance. YAGNI demands restraint.

Share

The speed of agentic coding is breathtaking. The short-term productivity boost is remarkable; the time savings often outweigh the cost of abundant code generation in the initial phase.

But could that abundance be insidious? Could it be creating a massive, long-term maintenance burden?

Abundance compounds. Unnecessary code doesn’t just sit there quietly. It creates drag. It demands maintenance. It hides bugs. It slows down everyone who comes after you. The technical debt piles up faster than ever before, not because writing code is hard, but because deleting it requires judgment. And judgment takes time.

The cost of managing complexity remains the core constraint. The problem isn’t the writing, it’s the managing what you actually ship.

It’s likely that we can’t stop the AI from generating abundance. We just need to stop the abundance from being integrated into the final product.

This is the necessary shift: YAGNI transitions from being an internalized developer bias to a mandatory post-generation architectural governance strategy.

The new mandate is simple: Aggressively delete code you don’t need before you ship.

How do we do this?

1. Spec-Driven Prompting: Constrain the beast at the source. Ambiguity encourages LLMs to generate verbose, multi-path solutions. Your prompt is the highest level of control you have. Use simple, structured commands and rigid frameworks to limit the AI’s scope to only the necessary artifacts. Enforce YAGNI at the prompt layer.

2. Bonsai Programming: Or, let the AI run wild, then prune relentlessly. Like a bonsai master, your job is to shape what grows naturally into something intentional. The bottleneck isn’t writing anymore—it’s choosing what stays and what goes. The work is in the pruning.

Value can’t be speed above all else. There is another measure for us to consider.

The goal is simple: achieve low final complexity metrics, despite the high initial volume of the AI draft.

This is the true measure of success in the AI era: the Feature-to-Code Ratio.

Are you building a lean, simple, robust system, or are you burying a handful of required functionality inside an avalanche of unnecessary code?

The era of AI coding agents fundamentally shifts the challenge from minimizing the time spent writing code to minimizing the complexity of the code ultimately integrated into the system.

Architectural simplicity must be intentionally managed, tracked, and enforced, regardless of whether the initial lines of code were produced by a human or a machine.

Don’t let the velocity blind you to the cost of clutter. Prune with intent.

That’s the new work.