AI, Code Bloat, and the Eternal Struggle for Simplicity

If you’ve been on tech Twitter, Hacker News, or anywhere near a Reddit comment section lately, you might think AI is either about to solve everything… or burn everything down, including your CI/CD pipeline and your weekend.

One of the most common criticisms?

“AI can’t even manage large, complex systems—it just generates spaghetti code at scale!”

To which I say: Oh, sweet summer child… you think this is new?

The truth is, we’ve always struggled with complexity. Human engineering—especially in software—has long resembled a group project where half the team builds microservices, the other half builds monoliths, and someone decides the answer is YAML.
(You know who you are.)

🧙 Back in My Day… (Cue the Unix Philosophy)

The original Unix wizards gave us wisdom that still echoes through the halls of GitHub:

• Make each program do one thing well.
• Don’t clutter output.
• Throw away the clumsy parts and rebuild them.
• Use tools, not people, to do boring things.

Sound familiar?
It should. It’s practically the DevOps Manifesto’s quirky great-uncle.

These ideas weren’t about minimalism for the sake of aesthetics—they were survival tactics for dealing with complexity before it became technical debt with a 401(k).

🤖 Enter AI: Now With 10x the Bloat

Fast forward to today. AI is writing code, testing it, documenting it (sometimes), and even refactoring it—all at lightning speed. But instead of ushering in a utopia of clean, modular systems… we’re getting functions named doThing2() and files that are 2,000 lines of maybe-useful glue.

It’s not that AI is bad at this. It’s that managing complexity is hard, full stop. Whether the code is written by an LLM or Larry from IT, the entropy remains.

But here’s the good news: the principles haven’t changed.

• Don’t let features snowball into Franken-apps.
• Build cleanly, test early, and rebuild shamelessly.
• Compose small things into bigger, better things.

AI doesn’t fix our messy engineering history—it inherits it.
And maybe that’s okay.

🛠️ So What Now?

Let’s stop expecting AI to magically solve architectural problems we’ve been wrangling for decades. Instead, let’s teach it the values that we should still be practicing:

• Modularity over monoliths.
• Clarity over cleverness.
• Simplicity over “look what I can do in one line of Python.”

If we give AI the right patterns, the right constraints, and—dare I say—the right philosophy, maybe it won’t just generate code.
Maybe it’ll help us generate better systems.

And if not?
At least it’ll still be better than Bob’s legacy Perl script we’re all too afraid to touch.

What’s your take? Have we learned from the past—or are we just automating our bad habits faster? Let’s discuss (but please, no spaghetti-flavored metaphors in the comments).