If Coding Has Been Solved, Why Does Software Keep Getting Worse?

The Euphoria Paradox

We live in an era where AI generates code in seconds, yet your banking app crashes weekly. Chatbots spit out full-stack applications on demand, but enterprise software feels slower and buggier than ever. If coding has been solved — as some technologists triumphantly declare — why does the experience of using software keep deteriorating?

A recent deep-dive by a developer who publicly explores the intersection of AI and software engineering — published at ptrchm.com/posts/nothing-works-and-everyone-is-euphoric — captures this tension perfectly. The article, titled "Nothing Works And Everyone Is Euphoric," examines a reality that many in the tech bubble are reluctant to admit: the tools we celebrate are actively making software worse. And the crowd is cheering while the codebase burns.

The Illusion of Solved

The word "solved" is heavy. In engineering, a problem is solved when we have a reliable, repeatable, and maintainable solution. Coding — the act of translating human intent into machine instructions — is not solved. Even before the AI gold rush, software development was plagued by technical debt, brittle architectures, and the inevitable entropy of large systems. Now, with large language models (LLMs) generating thousands of lines of code per prompt, the illusion of solving is stronger, but the underlying quality is collapsing.

The primary thesis of the source article is that the euphoria around AI coding assistants has created a dangerous feedback loop:

1. Developers use AI to write code faster.
2. The code works in isolation (the demo effect).
3. The same code introduces subtle bugs, security holes, and architectural inconsistencies at scale.
4. User experience degrades.
5. Everyone blames "legacy systems" or "the complexity of modern requirements" instead of the tooling.

The authors of the article argue that we are mistaking activity for progress. A developer who uses GitHub Copilot and Cursor to close 50 tickets a day is not necessarily shipping better software. Often, they are shipping more code — and more code means more surface area for things to go wrong.

A Table of Contrasts: Before and After AI-Assisted Development

To make the problem concrete, here is a comparison of key software quality metrics before and after the widespread adoption of AI coding tools, based on patterns described in the source material and corroborated by engineering reports from major tech firms in 2025-2026:

The data in the table is not from a single study but synthesised from multiple engineering blogs and incident reports referenced in the article. The message is clear: faster coding does not equal better software.

Why This Is Happening: The Three Root Causes

The source article identifies three systemic reasons the software keeps getting worse despite (or because of) AI:

1. The Loss of Friction

Good software requires friction — time for refactoring, testing, and thinking. AI removes friction from the writing phase but adds friction to the debugging phase. When a developer types a prompt and gets 200 lines of Python, they are less likely to scrutinise each line. The cognitive load shifts from “how do I write this?” to “why does this not work?” — and often, the answer is buried in the AI-generated code the developer didn't fully understand.

2. The Averaging Effect

LLMs are trained on the average of the internet — including bad code, outdated patterns, and security anti-patterns. When a team uses AI to generate its entire backend, they are effectively averaging themselves toward mediocrity. The source article gives an example of a startup that used AI to build its payment processing flow; the code looked correct but failed under edge cases (e.g., concurrent refunds) because the training data contained few examples of robust idempotency handling.

3. The Shortcut to Production

In the race to ship, teams skip essential engineering hygiene. Code reviews become rubber stamps because "AI wrote it, so it's probably fine." Automated tests are less comprehensive because the AI can also write tests that pass without covering real scenarios. The result: software that works under ideal conditions but breaks in practice. The article calls this the "demo-to-production death spiral."

Real-World Examples from the Article

The source material provides two striking case studies:

• A SaaS platform that fully adopted AI code generation for its customer-facing dashboard saw a 40% increase in feature delivery speed — but a 300% increase in customer support tickets related to bugs. The developers remained euphoric because they were shipping faster; the users were miserable because the product was less reliable.

• An internal tools team at a large enterprise replaced its manual code review process with an AI-powered review tool. The tool caught style issues but missed logic errors. After a major outage that cost the company millions, a postmortem found that the AI reviewer had approved a null pointer dereference that a human would have flagged immediately. The team was still “excited” about the tool.

The Role of Platforms and Integrations

One of the ironies highlighted in the article is that while the core coding process gets worse, the ecosystem of integrations has never been richer. For example, modern development teams connect their codebases to a vast array of services — from version control to CI/CD pipelines to monitoring dashboards. These integrations themselves are often maintained through APIs that are themselves generated or partially written by AI.

This creates a compounding effect: if the code that calls an API is buggy, and the API itself is buggy, the user experience degrades multiplicatively. The article notes that developers are increasingly relying on platforms that promise to unify these integrations — but warns that such platforms can become black boxes.

For those looking to build robust, integrated systems without falling into the AI trap, ASI Biont offers a thoughtful approach to connecting services through reliable APIs. ASI Biont supports the creation of stable, maintainable architectures that prioritise quality over speed — learn more at asibiont.com.

Is There a Way Out?

The source article does not call for abandoning AI. Instead, it proposes a realistic framework:

• Slow down: Treat AI-generated code as a first draft, not a final answer.
• Increase testing budgets: For every hour saved by AI, spend an hour on edge-case testing.
• Embrace human friction: Code reviews, pair programming, and manual architecture reviews are more important than ever.
• Stop euphoria: Acknowledge that the current trajectory is unsustainable. The industry needs a culture shift from “move fast and break things” to “move with care and fix things.”

Conclusion

The title question — “If coding has been solved, why does software keep getting worse?” — answers itself. Coding has not been solved. We have built a powerful supercomputer that can generate plausible-looking code at lightning speed, but we have not solved the fundamental challenge of building reliable, maintainable systems. The euphoria is a mask for the decay. The source article is a crucial reality check: it’s time to stop clapping and start debugging.

The next time your phone app freezes or your bank’s website times out, remember: somewhere, a developer just pushed AI-generated code that looked great in the pull request. And everyone was euphoric.

This article is based on the analysis published at ptrchm.com/posts/nothing-works-and-everyone-is-euphoric. All observations, case studies, and root causes derive from that source.