Skip to content

Blog

Is AI Making Code Quality Obsolete? Rethinking Structure in the Age of LLMs.

A challenging question has emerged across development circles: "Since AI can generate functional code rapidly, do classical principles like good architecture, clean code, or rigorous encapsulation still matter?"

The premise is highly seductive. We are operating at an unprecedented layer of abstraction. If an advanced agent can replicate a logging block across dozens of services in minutes, does the effort spent on defining modular boundaries or adherence to SOLID principles truly pay off?

While the sheer velocity afforded by Large Language Models (LLMs) demands our attention, I believe there is a critical misunderstanding about where the primary constraints lie. The challenge is shifting from human manual labor to managing economic viability and institutional knowledge debt.

Here is my analysis of why rigorous architecture remains essential, perhaps more so than before.

When the Team Becomes the Process

Good people can hide complexity debt for a long time. Sometimes things have to break before anyone believes there was a problem, and most of us have watched that play out at least once. Not because anyone was doing the wrong thing, but because everyone was doing the right thing: bridging the gap, covering the issue, keeping the service running and the client out of pain.

Paying Down Knowledge Debt: Finding the First Seam

In my last post I argued that the way to modernise a large, tangled system is not a full rewrite but the strangler fig, carving off one piece at a time. Which leaves the real question: which piece first? A seam is simply a place you can change one side of a line without disturbing the other. In a tightly coupled system those lines are faint, but rarely absent. Here is the order I look in.

Paying Down Knowledge Debt: The Rewrite Temptation

In my last post I wrote about Knowledge Debt, what happens when we stop understanding the systems we ship. The obvious follow-up: what do we do about it, especially in the large, long-lived codebases where it has compounded the longest?

AI coding demonstrations rarely resemble those systems. They start from an empty folder, which has no history to misunderstand. We work in the opposite conditions: decades of accumulated behaviour, outdated documentation, and critical rules living only in the memory of people who may have long since left.

Knowledge Debt: The Harder Problem

We talk a lot about tech debt. We're about to learn that Knowledge Debt is the harder problem.

There's a growing debate in our industry, on one side, the "vibe coders" who greenfield entire applications with AI agents without a second thought. On the other, experienced engineers like Zoran Horvat who warn, with good reason, that we're sleepwalking into a profession we no longer understand.

Both sides have a point. But I think we're missing something in the middle.