AI Has No Wisdom and Neither Will You - Alexandru Nedelcu
Alexandru Nedelcu ☕️
Blog
Wiki
About
Subscribe
AI Has No Wisdom and Neither Will You
September 22, 2026
| 5 minutes
| Comments
In the past month alone I’ve heard these phrases:
I haven’t written code since 2025;
Code reviews are dead;
People no longer read code.
Certainly the industry is transforming, however, the people and organizations falling into the trap of no longer reading and writing code only do so at their peril.
Fact is, vibe-coded projects devolve over time into an unmaintainable mess. The reason is simple, yet hard to fix: code maintainability and good architecture don’t have good measurements that we can apply, because it takes months, years even, to notice the effects of bad architecture or of unmaintainable code.
We can certainly define bad code: code that’s hard to read, hard to understand, hard to evolve for whatever the future throws our way. The kind of code in which changing one thing breaks the program in very non-deterministic ways, or breaks the logic somewhere else, far removed from your change, resembling the “butterfly effect”. The kind of code where adding a feature means a serious undertaking due to changing code in multiple places and still forgetting to patch everything, thus getting inconsistencies. Code in which the invariants of the design aren’t clear, with its authors no longer being around to guard against violations and ensure some coherence. Code that is hard to test, requiring mocks and exposing implementation details, leading to fragile tests that end up preventing meaningful refactoring.
And yet, we know it as a fact that noticing bad code takes time. Months, years. Of course, the experienced software engineers have a nose that can detect code smells and can take action long before the bad effects can be observed.
The proficient developers, the experts, rely on their intuition built with sweat and tears, working long hours trying to debug and fix production issues, swearing to never again be so foolish as to repeat past mistakes. It’s the kind of intuition that can’t really be made into a list of rigid rules, because everything is context-dependent. Experts are incompatible with the same rules and recipes that make beginners more productive. Experts don’t follow the rules, they make the rules.
And so we have a problem…
For one, AI is not trained on what it means for code to be maintainable. For instance, any reinforcement learning done needs a reward signal that can be measured immediately, not in months or years. The AI learns rules from rulebooks meant for beginners. The AI notices patterns from code in the wild and let’s be honest, most code in the wild is pretty bad. There is no fitness function you can define for maintainable code, at least not one that we can discern, otherwise it would’ve been baked into our linters.
Have you noticed how terrible is the AI at “simplifying” code? Yes, the SOTA models. It can’t even define functions properly, choosing to split functions into smaller functions that are not actually reusable. Extracting a smaller function from a bigger function is a very bad choice if, to understand the bigger function, you have to also read the implementation of the extracted smaller function. Defining reusable and clarifying functions is an art form, an art that takes mastery. Most developers, being still “advanced beginners” in the Dreyfus model, are not able to define good, clarifying, reusable functions and neither does the AI currently.
This wouldn’t be so bad if people would still be in control and learn from those mistakes. But we are seeing a trend of people relying on AI to write, and even read code.
Those people will never reach mastery, because they no longer make choices, they no longer take responsibility for mistakes in coding and no longer learn from those mistakes. It’s the AI that’s making mistakes now, the AI doesn’t learn from those mistakes, and neither are the people relying on AI for coding.
Yikes!
Don’t get me wrong, I think LLMs are a great tool. I’m no Luddite, I’ve integrated AI in my everyday work, while actually teaching my colleagues what I’ve learned. I gladly use LLMs to take care of all the boring, soul-sucking shit we have to deal with. I’m also enjoying the efficiency benefits that I’m seeing. But at the end of the day, it’s just a tool, and like all other revolutions, its light will also fade; IMO, it already is, as right now tech news is frankly quite boring.
People are actually terrible at making predictions. I believe the future will surprise all of us. But, I’m going to make a prediction of my own…
In the future we will see more and more companies proudly boasting their “NO-AI” policy as a competitive advantage. And they will be right.
“But automated assembly lines are always more efficient” people say, except that the software industry is special, because we’ve always done automation at scale, everything we do is automation, LLMs are not the only means for it, and depending on context, it may actually be a distraction. “Coding isn’t solved” in any meaningful sense. Sure, you can instruct the LLM to build you a C/C++ compiler, or you can just clone GCC or LLVM, and you’d get a better C/C++ compiler, for free, too. And maybe there are better ways to spend our time and resources than reinvent the same CRUD apps (human needs and desires are infinite, there’s no shortage of new goals to work on).
If people and companies don’t start being responsible about its use, there will be consequences.
Updated: September 22, 2026
| Written by Alexandru Nedelcu
Tags:
AI
|
Opinion
Related Articles #
Copyright is Dead
AI
| Open Source
| Opinion
March 6, 2026
Boring Tech May Become Irrelevant Tech
AI
| FP
| Opinion
| Programming
| Languages
March 5, 2026
Programming Languages in the Age of AI Agents
AI
| FP
| Opinion
| Programming
| Languages
November 16, 2025
Comments
#
Want to chat in private? Email me:
Email address is protected via JavaScript, activate it to see it!
The address is changed periodically to avoid spam.
Enable JavaScript to see the email address or the public comments!
Commenting widget is powered by a self-hosted commenting server.
Read the privacy policy.
Contribute
#
Fix or add to this article by submitting a pull request:
Edit Page on GitHub
Subscribe
#
Subscribe by email
and receive notifications for new blog articles. No spam, just content.
Powered by Mailchimp.
See privacy policy.
Email Address *
© 2009-2026
License |
Privacy Policy |
Contact |
The author posits that despite the transformation occurring in the industry, where phrases like outdated practices suggest a shift away from traditional coding methods, those who neglect the principles of code writing and maintenance risk significant consequences. The core issue stems from the fact that issues related to code maintainability and good architecture lack measurable metrics, meaning the negative effects of poor structure often remain undetected for months or years. The author details what constitutes poor code, describing it as code that is difficult to read, understand, and evolve, exhibiting non-deterministic behavior when changes are made, causing inconsistencies when adding features, lacking clear design invariants, and yielding fragile tests that prevent meaningful refactoring.
Experienced software engineers develop an intuition through extensive experience that allows them to detect code smells long before detrimental effects materialize. This expertise is context-dependent, making it incompatible with rigid rule sets, as experts often create the rules themselves rather than adhering to them. This contrasts with the limitations of artificial intelligence, which is not trained on the concept of maintainable code; reinforcement learning requires immediate reward signals, which code maintainability does not inherently provide. Furthermore, the perceived inability of state-of-the-art AI models to effectively simplify code, such as properly defining functions or extracting genuinely reusable components, highlights a gap where mastery—the art of clarifying and structuring functions—is absent in both developers and current AI systems.
The author warns against a trend where reliance on AI for coding and reading diminishes human expertise. If professionals delegate responsibility and cease learning from coding mistakes, they will fail to achieve mastery. The author acknowledges the utility of large language models as a tool for handling tedious tasks and efficiency gains but suggests that this reliance is temporary, anticipating a future where organizations adopt "NO-AI" policies as a competitive advantage. While automation is efficient, the author argues that the software industry is unique, and coding is not fundamentally solved. The author concludes by emphasizing that if people and companies fail to take responsibility for how they utilize these technologies, negative consequences will ensue. |