Rapid Code, Rapid Decay: How AI Tools May Repeat 90s RAD Mistakes

🔊 Listen to the Podcast version here. 🔊

AI Copilots Are the New 90s Citizen Developers (Only Worse)

Picture this… It’s 1995 and an ambitious accountant just built a mission-critical application using Microsoft Access. It works like a charm, - until it doesn’t. Fast forward to 2025 and instead of rogue office workers building shaky applications, we have AI coding assistants generating code by the thousands of lines in minutes. The tools have changed, but the story might be the same, with one twist. This time, the aftermath could be even messier.

Déjà Vu: 90s ‘Citizen Developers’ vs Today’s AI Coders

In the early 90s, so-called “citizen developers” emerged thanks to office-friendly tools like Microsoft Access, Visual Basic, and PowerBuilder. Business users, - non-engineers, could suddenly whip up their own software. It was empowering, but it often created a false sense of proficiency. Yes, these amateur programmers delivered quick solutions and some even went on to become programmers extraordinaire, but under the hood those applications were usually a ticking time bomb,- no solid architecture, zero version control, flimsy security, and data scattered in ways that kept IT folks awake at night.

Fast forward to today… AI-powered development environments like GitHub Copilot and Cursor are sparking a similar revolution. Now anyone who can describe what they want in plain English can generate code. It’s 1995 all over again, in spirit. The messes that used to be confined to departmental Access databases are reappearing as AI-generated scripts and applications scattered across organizations. In some enterprises, decades-old Microsoft Access macros still haunt their operations like zombies that won’t die (Young Coder). That same breed of hard-to-kill, hard-to-maintain software is poised to make a comeback, - this time turbocharged by AI.

Missing the Forest for the Trees

There’s a fundamental limitation with these AI coding tools. They can’t see the forest for the trees. An AI will confidently churn out code that solves the immediate problem you asked it to solve, but it has zero awareness of the bigger picture. It doesn’t ponder how that function fits into the overall system architecture, whether it violates your company’s security guidelines, or if it creates ten new versions of a function that should have been a single reusable module. For now, AI lacks the architectural coherence and long-term perspective that experienced human developers bring.

Back in the 90s, novice-built apps often lacked proper structure. Today, AI is doing the same thing at scale. Redundant code is ballooning. One study observed an 8-fold surge in duplicate code blocks, with redundancy now ten times higher than just a couple of years ago (LeadDev). That is a neon warning sign. Instead of refactoring or integrating with existing libraries, AI might just copy-paste a slightly tweaked chunk of logic somewhere else. The result? Bloated, fragmented codebases that are harder to maintain. And if you think debugging a human’s messy code is hard, wait until you’re sifting through AI-generated logic that even the ‘author’ (the AI) doesn’t truly understand.

Same Mistakes, Higher Stakes

‘I don’t think I have ever seen so much technical debt being created in such a short period of time,’ said Kin Lane, a veteran technologist with 35 years in the field (LeadDev). In other words, this isn’t just a rerun of the 90s, - you could call it a sequel with a much bigger budget for pyrotechnics. Several factors make the current situation far more dangerous than that earlier era:

• Sheer volume and speed – In the 90s, our enthusiastic accountant could only create code as fast as he could type. Today, an AI assistant can generate thousands of lines in the blink of an eye. That means a single developer or even a non-developer can unleash an avalanche of new code overnight. The technical debt piles up faster than ever. In fact, a recent survey found 67% of developers now spend more time debugging AI-generated code than actually benefiting from its purported speed boost (harness).

• The sophistication illusion – Unlike a clunky Access form with Comic Sans buttons, AI-generated code often looks legit at first glance. It has proper indentation, comments, and a veneer of competence. This polish gives executives and teams a false sense of security. Garbage code that looks professional is even more dangerous because it sneaks past our skepticism. In the 90s, at least you could recognize a rickety spreadsheet app when you saw one. Now the junk code comes dressed in a suit.

• Enterprise-scale impact – Those Access databases from decades ago usually lived in one corner of the company until they quietly became mission-critical. By contrast, AI-generated features are finding their way into core production systems right away. Modern software is deeply interconnected. An AI-crafted microservice isn’t just a toy app on someone’s PC, it’s potentially a customer-facing component. When something goes wrong, it could hit the entire business, not just a single department.

• The new shadow IT – Remember how IT departments in the 90s would discover an unofficial Access database running payroll or inventory? We’re headed there again. AI tools let people build software outside the normal development pipeline. According to recent findings, over half of developers don’t even use the AI tools officially sanctioned by their IT departments (harness). This unsupervised use of AI is creating a wild west of shadow development. Critical business logic might be woven into AI-spawned scripts that nobody fully understands or governs.

Long-Term Implications: Why It Matters

If anyone thinks all this duplicated, AI-spawned code is harmless, think again. The long-term implications are very real and very costly:

• Wider impact – In the 90s, a bad app might bog down a team or a department. In 2025, an AI-generated mess can spread across an entire enterprise. We’re talking company-wide slowdowns, crashes, or data integrity problems if that code was integrated broadly. The blast radius of bad code is orders of magnitude larger now.

• Critical systems at risk – Today’s AI is writing code for healthcare, finance, infrastructure, - domains where failures can be catastrophic. This isn’t a goofy office spreadsheet. It’s potentially the software in your pacemaker or your bank’s mobile app. The stakes for quality and security have never been higher.

• Debt that’s harder to repay – The legacy of AI’s coding spree will be millions of lines of tangled code. Replacing a few Access databases was an expensive headache. Now, imagine untangling a web of AI-written services spread throughout your cloud environment. The cost and complexity of rework later could dwarf the initial savings of quick AI-generated wins.

• Skill erosion – Relying heavily on AI might atrophy the skills of human developers. If an entire generation of programmers grows up letting the AI handle the details, who will be equipped to do the hard work of refactoring and system design later on? Technical debt isn’t just a code problem, - it’s a people problem. We risk breeding complacency at exactly the moment we need sharp engineering minds to keep these AI factories in check.

How to Avoid Repeating History

We aren’t doomed to relive the 90s nightmare on a grander scale. With the right approach, organizations can harness AI’s benefits without accumulating impossible debt. Here’s how to tilt the odds:

• Governance first – Establish strict guidelines and oversight for AI-generated code. Decide where it’s acceptable to use AI in development and where a human needs to stay in the loop. Review AI contributions with the same rigor as any outsourced code, if not more.

• Quality over quantity – Stop measuring developer productivity in lines of code,- especially now. Set clear code quality metrics: (1) duplication rates, (2) complexity, and (3) maintainability scores should trend in the right direction. Reward developers for fixing problems and refactoring, not just pumping out features.

• Educate and train – Ensure your team understands that AI is a helper, not a replacement for design and thought. Train developers and enthusiastic non-developers in the fundamentals of secure, maintainable coding. Everyone using these tools should know their limits and the importance of architecture and testing.

• Refactor as you go – Make it a mandate that all AI-generated code gets a human review and cleanup. Treat AI drafts as exactly that: drafts. Bake refactoring and simplification into your development cycles so that the quick and dirty code doesn’t stay dirty.

• Use AI to assist, not autopilot – Pair AI tools with strong engineering discipline. Let AI handle the boilerplate and suggest solutions, but have human developers make the critical decisions. Think of AI as a junior developer: fast and helpful, but it needs supervision and mentorship.

The bottom line: History doesn’t have to repeat itself. We have an opportunity to learn from the 90s and impose some adult supervision on our eager new AI assistants. Those who embrace AI in a thoughtful, disciplined way will sprint ahead of competitors, - without tripping over a giant pile of technical debt. The future of coding can be exciting and efficient, but only if we remember that faster isn’t always better, and more code can very easily mean more problems.

---

Further Readings

• How AI generated code compounds technical debt (Bill Doerrfeld, February 2025) A concise look at GitClear’s data showing surging code duplication and declining code reuse due to AI coding assistants.

• AI Makes Tech Debt More Expensive (Evan Doyle, February 2025) Explains how generative AI widens the gap between well-maintained and messy codebases, increasing the costs of carrying technical debt.

• Why AI-generated code is creating a technical debt nightmare (Alexander Procter, March 2025) Discusses the rapid accumulation of technical debt from AI-produced code, drawing parallels to the low-code chaos of the 90s and offering strategic advice.

• Can AI solve your technical debt problem? (Josh Fruhlinger, April 2025) Explores whether AI tools can help manage technical debt or if they simply shift the burden, ultimately emphasizing the enduring need for human judgment and best practices.

---

Disclaimer: The perspectives shared in this article are my own and do not represent those of my employer or any affiliated organizations. All company names, product names, logos, and brands mentioned are the property of their respective owners and are used for identification and illustrative purposes only. No endorsement, sponsorship, or affiliation is intended or implied. References to specific companies or case studies are based on publicly available information and are used solely for educational and discussion purposes.

---