Clean code is dead. The AI doesn't care about your variable names, your single responsibility principle, your beautifully extracted service classes. It'll read your 800-line controller and generate another one without blinking. The humans are leaving the loop.

Why are we still writing code for them?

Because the AI is the loop now. And you just taught it everything.

The Pattern Matcher in Your Codebase

AI assistants are pattern matchers. Your codebase is the pattern.

Every autocomplete suggestion, every refactor request, every "explain this function" runs through a model trying to understand what normal looks like here. What the conventions are. What this team considers acceptable.

It doesn't read your best code first. It reads all of it, equally. The clean service you wrote on a good Tuesday and the nightmare controller you hacked together at 6pm before a deadline carry the same weight. Same influence. Same lesson absorbed.

You already have an AI apprentice. It showed up the moment you installed Copilot, opened Cursor, or started pasting code into Claude. No interview. No onboarding. It just started watching and learning.

A human junior eventually pushes back. Asks "should this really be in the controller?" Gets uncomfortable and starts questioning it. The AI never gets uncomfortable. It sees the fat controller and thinks: this is how we do things here. Then it makes another one. Faster. With more features. In places you haven't looked at yet.

The question isn't whether it learned from you. It's what you taught it.

Someone Has a Different Theory

Last week, Joppe De Cuyper published "I deleted my source code." He built a Symfony app with an empty src/ directory. No committed code. On every CI run, an AI agent reads a spec file and a test suite, generates the full implementation, runs the tests, and throws everything away. The spec is the source. Code is a build artifact, like a compiled binary.

His conclusion: code is becoming disposable. Clean code is a convention we built for humans, not machines. The machine doesn't care about your naming. It'll generate an 800-line controller and move on.

The direction of travel is real. But his proof of concept is a greenfield TODO app. Clean domain. Controlled from the start. No legacy, no accumulated edge cases, no fix from 2019 that lived only in the implementation because nobody updated the spec.

He admits it himself: "Most knowledge in a codebase is implicit." The bug you fixed last year. The subtle business rule that exists because a client complained once in 2022. The performance hack that solved a real production problem. None of that is in the spec. It's in the code. Regenerate, and it's gone.

His experiment works because he controlled every variable. Most of us are working in codebases that have been out of control for years. There's no spec to regenerate from. There's just what was left behind. And the AI is working from it right now, on the ticket that just got assigned.

The Machine Absolutely Cares About Your Variable Names

This is the part of Joppe's argument that sounds right and isn't.

The interpreter doesn't care. $x parses identically to $userEmailAddress. The runtime has no opinions about your naming choices.

The AI assistant isn't the runtime. It's an LLM, and LLMs understand code through semantics. The meaning of names. The shape of structures. The relationship between concepts. All of it feeds into how the model reasons about what your code does and what it should do next.

A method called process() that does three different things depending on an internal flag gives the model nothing. It guesses. Then it commits to that guess, because these models don't say "I'm not sure." They pattern-match to the most plausible continuation and ship it.

A method called markTaskAsCompleteIfSubtasksAreDone() is a different thing entirely. Preconditions, side effects, intent — all communicated before a single suggestion is made. Every line generated nearby is shaped by that clarity.

Clean naming isn't aesthetics. It's signal. Signal is what separates an AI that makes you faster from one that introduces bugs in files you haven't opened in months.

Give it noise, it generates noise. That's not a metaphor. It's just how the math works.

The Debt Doesn't Sit Still Anymore

You've been tolerating a mess. The deadline was real. You'd clean it up later. Only teammates would see it.

That tolerance used to cost one thing: a developer, slowed down, on a future ticket. Annoying. Manageable. The kind of debt you could argue you'd eventually address.

The AI changed the math.

Every bad pattern is now a lesson that gets applied again, faster, in more places, with more confidence, across every interaction with your codebase until someone cleans it up. The debt has an engine now. Tireless. Tasteless. Incapable of telling the difference between your best work and your worst.

It used to be linear. Now it compounds. It's been compounding since the day you gave it access.

Specs and Clean Code Aren't Alternatives

Joppe gets one thing right: specs should be where decisions live. Explicit, testable, precise. If your spec isn't detailed enough to generate correct code from, it wasn't detailed enough to build correct code from by hand either.

But specs describe what. Code is where how lives. How you handle two events arriving out of order. How domain logic stays separated from infrastructure. How the subtle business rule actually gets enforced when things get messy at runtime. No spec captures all of that. The implementation is still full of decisions, and when those decisions are buried in noise, the AI guesses at them. Repeatedly. Confidently.

Precise specs make the AI more capable. Clean code makes it more correct. Not competing priorities. Two layers of the same problem.

Write better specs. And clean up the code you actually have today, because that's what the AI is reading right now.

So What Did You Teach It?

The AI is reading your codebase while you read this. Building a model of what normal looks like. Your patterns. Your shortcuts. Your tolerated messes.

In six months, when you open a file you don't recognize, you'll know whose fault it is.

You wrote the curriculum. You left the mess on the desk and called it pragmatism.