Lately we use AI assistants heavily, both in our own projects and at work. While cycling or walking in the evenings, one question kept coming back to me: do AI assistants (Claude, Gemini, ChatGPT and so on) really speed up our productivity, or do they just postpone technical debt into the future?
Generating hundreds of lines of code in seconds with a few prompts is great, but once the work reaches production it may not be so great after all. After reading a few papers on the subject (Debt Behind the AI Boom, The Great Toil Shift and post-2026 industry analyses), the data makes it clearer: we are not writing code with AI, we are putting debts we will pay later on an instalment plan.
Let's look at what I found.
1. The "It Works, Don't Touch It" Fallacy
The Debt Behind the AI Boom study examined 6,299 open-source GitHub repositories and more than 300,000 commits and paints a very clear picture. 89.3% of AI-induced issues are not fatal errors that crash the system immediately. On the contrary, they are what the literature calls code smells: architectural flaws waiting quietly.
Unnecessary parameters, except: pass blocks that silently swallow errors, functions written without context... Even more worrying: 22.7% of faulty AI-generated code gets past experienced code reviewers and into the main project, because the code looks perfectly sensible and plausible at first glance.
2. The Great Toil Shift (The Great Toil Shift)
AI was supposed to save us time and remove the drudgery. According to SonarSource and post-2026 analyses, the drudgery didn't disappear; it changed shape. We used to spend most of our time writing code, building logic and designing architecture. Now that time goes into reading, understanding and verifying AI-generated code that looks great from the outside but hides logical gaps (hallucinations) underneath.
As developers we have moved from being "writers" to being "editors" who constantly proofread. And this creates a major bottleneck in human approval.
3. Back to Spaghetti Code and Architectural Decay
AI assistants are incredibly fast but lack a holistic view of the architecture. They focus on solving the problem in front of them, as far as the context window allows. Instead of reusing existing helper functions or refactoring the current structure, they keep producing new blocks of code that are similar but slightly different.
This code bloat slowly eats away at the structural integrity of a project. Patching on top of patches without understanding the whole system takes us back, with a next-generation ticket, to the spaghetti-code hell we tried so hard to escape years ago.
So What Should We Do?
After all these bad scenarios, of course we should keep using AI to be productive, but we have to accept that things are not as simple as they look from the outside:
- First, we need to learn how to write good prompts, because good prompt = good output.
- We should prioritise code quality and add more test scenarios.
- If we are taking on technical debt, we should identify its limits and future cost early and take steps to prevent it.
No matter how far technology advances, the human mind and discipline are still critical for clean architecture, the right data standards and sustainable projects. While we think we are flying with AI, we should not forget that we may only be postponing the fall.
