Good Code Will Still Win

AI is writing more code than ever. PR sizes are up 33%. Lines of code per developer jumped from 4,450 to 7,839. And outages? They're climbing too.

The temptation is to assume this is the new normal — that "slopware" wins and clean code is a relic. But that assumption is wrong. And the reason it's wrong is pure economics.

The Slopware Moment

Ryan Dahl, creator of Node.js, recently said it plainly: "The era of humans writing code is over." That's a scary line for anyone who identifies as a software engineer. And it's not entirely wrong — AI coding tools are generating a massive share of new code.

But look at what that code looks like. Andrej Karpathy describes it honestly:

This is the slopware moment. Code generators churning out bloated, copy-pasted, context-heavy messes. It works — until it doesn't. And "until it doesn't" is arriving faster than expected: analysis of vendor status pages shows outages have steadily increased since AI coding tools became standard practice.

Why Slop Doesn't Scale

Here's where the economics kick in.

John Ousterhout's A Philosophy of Software Design makes the case that complexity is the #1 enemy of well-designed software. Bad code needs a lot of context to understand. Good code hides implementation details and creates deep modules with shallow interfaces.

Now think about this from an AI perspective:

• Bad code needs more tokens. Every time an AI touches complex, bloated code, it needs to load more context into its context window. More tokens = more cost.
• Bad code needs more iterations. Slop code breaks in edge cases. Fixing it means more generations, more compute, more dollars.
• Bad code compounds. One messy module makes the next module messier. The cost curve is exponential, not linear.

Good code, by contrast, is cheaper at every step. It needs less context to understand, fewer changes for maintenance, and fewer tokens over the life of the codebase.

The Competition Will Force It

Right now, AI coding tools compete on raw capability — who can generate the most code, fastest. That's the early-market race. But as the market matures, the competition shifts.

Developers and companies won't pay for tools that create more problems than they solve. The AI models that win will be the ones that help developers ship reliable features fastest. And reliable features require simple, maintainable code.

We're already seeing this play out:

• PR sizes are growing — median PR went from 57 to 76 lines in 8 months
• File changes are denser — 20% larger individual file changes
• Outages are increasing — software is becoming more brittle under the weight of generated code

The backlash is coming. When it arrives, the tools that produce clean, minimal, well-architected code will dominate.

What This Means for Builders

If you're building with AI coding tools right now, here's the play:

• Don't just generate — review. AI can write code fast. Your job is to make sure it writes good code.
• Invest in architecture upfront. A clean structure early means AI can work within it later. Garbage architecture + AI = faster garbage.
• Measure complexity, not lines. Track how hard it is to modify your code, not how much of it there is.
• Use AI for the boring parts. Boilerplate, tests, documentation — let AI handle the stuff that doesn't need creative architecture decisions.

The Bottom Line

We're in a messy phase. AI is generating more code than ever, and a lot of it is slop. But messy phases don't last forever.

Economic pressure will push AI models toward generating good, simpler code — because it's cheaper to generate, cheaper to maintain, and cheaper to extend. Markets don't reward slop in the long run.

Good code will win. Not because we want it to (though we do), but because the math demands it.

Read the original analysis from Greptile →