DEV Community

Erik Hazington
Erik Hazington

Posted on

Does code quality matter anymore?

I can't believe I'm going to do this, but I recently started to think that DHH might have been right when he said that "hand-written code is no longer economically viable". However, the reality is more nuanced than "coding is solved", and the consequences of this shift are probably not fully thought through.

The advantage of a healthy codebase

In the past, owning and maintaining a healthy codebase resulted in an actual competitive advantage, because rebuilding from scratch or compensating for tech debt slowdowns with more engineers was expensive. Too much technical debt could basically mean the end of your business. I learned this firsthand, because I solo-built and maintained the entire business suite and all IT systems of a globally operating aviation company with €30 million in revenue for almost two decades. Back then, my company's unique business model with 60 brands for 30 different services in 14 languages, 24/7 operations and 150 phone numbers targeting different customers and markets made it necessary to build custom software. I managed to build a system that hides the multi-brand complexity in a fast, secure, simple, intuitive and comprehensive application, where every piece of information is entered only once, related data is linked, and where users don't have to worry about the brand when working with clients or content in the headless CMS.

As the only person in IT, I inherited every hands-on and leadership role, including its unique responsibilities and risks. I had no other person to blame or ask, and even worse, no funding and no room for failures. In other words, I couldn't afford technical debt when I created custom end-to-end solutions from scratch as a self-taught engineer and system administrator. That's why I know many different perspectives of complex corporate IT systems, and it's also why I have a very strong focus on security and stability. Because of this situation, I had to automate all my stuff, and constantly refactor and modernize my codebase before even trying to build on top. I did everything to avoid and remove any sort of bloat, magic and hacks, unclear control flows, as well as unnecessary abstractions, complexity, functionality and vendors – and ultimately code I didn't fully understand. Without a team or manager, I had the opportunity to start building right away with just a goal or problem using an emergent goal-driven approach. I often didn't even know the final result, and sometimes ended up with an entirely different solution. Along the way, I got real-time feedback about the current state of my codebase, and often found and fixed flaws that I would have missed otherwise.

This approach has helped me to constantly modernize and maintain business-critical codebases for almost two decades now, and more importantly, to move and build fast without ever sacrificing code quality, performance, stability or security. My professional journey taught me to think in systems, starting with the operating system as the core for my applications.

Something has changed in 2026

Despite working alone for almost two decades, I'm well aware that many enterprise codebases are even worse than vibe-coded slop. As a result, large companies often hired more developers to mitigate the consequences of an unhealthy codebase, even though more people often resulted in more communication overhead, new types of errors and conflicts, which might decrease velocity even more. So the main advantage of a healthy codebase could be described as stable high velocity with a much smaller and overall less expensive team.

However, AI was supposed to change these economics of software. Some people even claimed that coding was solved, that code was cheap now. But until recently, I didn't find coding with frontier AI models impressive or useful. In my specific real-world scenarios, these agents simply hallucinated too much vendor code that didn't exist in my frameworkless application, and constantly violated my no-bloat policy and clean code principles. I spent more time telling these agents what they should not do, instead of being productive. So I stopped using AI, even though I had spent a lot of time making my existing isolated, least-privileged and secretless containerized dev environment AI-ready. I think they failed for me, because many of my custom solutions are deeply integrated and very similar to third-party code now existing in LLM training data, which isn't particularly surprising, because humans often end up with similar solutions that only differ in names.

Today, I still primarily use AI for research and learning, to discuss technical details, and to write simple utility scripts and isolated code snippets. However, as my dev environment allowed me to run AI agents securely (even with a web UI, thanks to OpenCode 2), I still tried new models from time to time. One of these models was Opus 5.5. It was actually the first model that was significantly better at "understanding" intent and working with what the codebase provided, instead of enforcing unrelated patterns from training data. It still makes stupid and dangerous mistakes, so I don't fully trust it, but this was the moment when I started to think that DHH might have been right about the changing economics of software development, and the moment I thought that AI agents might be capable of solving some real-world problems for me.

A bad codebase might no longer be expensive

Let's ignore for a brief moment that subscriptions are heavily subsidized, and that even API endpoints might be underpriced – but with current costs for tokens and capabilities like those of Opus 5.5, it might make sense to let AI agents build new features in a messy codebase, too. Agents would probably also benefit from higher code quality, but it certainly seems possible now to build functioning features in an unhealthy codebase with fewer human engineers. Especially when static analysis and a comprehensive test suite act as a strict and immutable verification layer. What I'm trying to say is that when a codebase suffering from technical debt no longer requires a larger human workforce to move forward, then it changes the economics of a bad codebase. In other words, the economic advantage of a healthy codebase might be gone.

But reality is more nuanced. Without strict verification, AI coding agents will make your codebase even worse and cause severe bugs. Even Opus 5.5 still makes dangerous mistakes. So depending on the state of the codebase, engineers must first invest time to write these tests, and implement quality tools, to make critical mistakes at least visible to the AI. But even under "perfect" circumstances, AI remains probabilistic and can still misinterpret what you want or what its changes actually do. So duplicate business logic, conflicting features, and unnecessary abstractions and control flows will still happen, which might cause performance issues, critical bugs and vulnerabilities. There are also a lot of edge cases in corporate systems where AI still is completely useless. So you better understand your system and be able to fix issues yourself.

We're trading reliability for numbers

Software development usually involves intuition and implicit goals that are hard to describe. These are benefits that only come into play when developers write code by hand or at least have written large amounts of code by hand. It is simply a different way of thinking that combines planning, designing and finding hidden flaws into a single task. But most importantly, it naturally limits you to the amount of code you can mentally process and understand. I genuinely believe that exceeding these limits eliminates almost all advantages of AI, and eventually causes more bugs.

Maybe it's just me, but software has become terribly unreliable since developers started using AI. Almost every tool I use today has annoying or critical bugs, crashes, or randomly wipes configuration data. Despite being still one of the best developer tools, even the IntelliJ IDEA isn't as reliable and stable as it was before AI. But I don't think AI is to blame here. I think it's our almost obsessive focus on velocity and the amount of code. We waste real money on numbers like LoC and PRs without any real benefit to the customer. I mean, I often remove more code than I add when I improve an application or add new features.

I'm not saying we should write all the code by hand again, even though we should do it from time to time to maintain ownership and mental health. But my actual point is that even if code quality might not be a strong competitive advantage anymore, it still matters to avoid bugs. We could do better than today, and we should do better, instead of writing more code that is impossible to review and understand. Instead of losing control, we should use AI to gradually improve our codebase, applications and systems, while delivering useful and functioning features to our clients at a predictable and steady velocity.

Top comments (0)