What Problems AI Creates for Programmers

Introduction

This article was inspired by a video discussing a paradigm shift in programming: replacing traditional programmer-coders with "prompt engineers" who work with AI. The author criticizes the superficial analysis in the video and offers his own examination of the problem.

Part 1: Differences in Professionals

The use of AI has led to the emergence of a new type of developer with three key differences from the classical programmer.

Lower Level of Technical Knowledge

A classical programmer spends long hours debugging, gradually developing a deep understanding of the problem. A prompt engineer can turn to ChatGPT without even reading the error message and copy the response without comprehension.

Debugging isn't just a chore — it's the crucible where real understanding is forged. Skip the struggle, and you skip the learning.

Decline in Project Knowledge

A traditional developer independently designs, implements, and verifies a solution, gaining deep understanding of the system. A prompt engineer saves time on development but loses knowledge of the project as a whole — the very thing that makes them a truly valuable specialist.

It's paradoxical: the time "saved" on understanding the system is actually time stolen from the developer's most valuable asset — their mental model of the project.

Loss of the Problem-Solving Process

For an experienced programmer, what matters is not just the results but the process itself, during which understanding of technological interconnections is born. A prompt engineer receives a ready-made result, skipping the educational process entirely.

Part 2: Problems with Code Quality

The core thesis: AI generates code that solves current tasks but creates future problems. This is explained by the fact that models were trained on predominantly low-quality code.

Unreadable Code

Code is written once but read many times — when studying the system, fixing bugs, and adding features. Code that's difficult to understand forces programmers to spend more time, which increases costs for the business.

Immutable Code

The principles of SOLID, KISS, DRY, and clean architecture were developed to create flexible code. As noted in the book "Clean Architecture": if code works incorrectly but is easy to change — it's easy to fix; if it works correctly but is hard to change — it will start working incorrectly as requirements evolve.

Code Diversity

You'd expect similar tasks within a project to be solved in similar ways. AI draws on code from different projects and authors, turning the project into a patchwork of approaches. This makes the code harder to understand even on the second or third reading.

Lack of Unified Architecture

LLM models work with a limited context window, seeing only the nearest code. AI cannot see the full picture of a project and cannot maintain a unified architecture, turning the system into a collection of separate fragments. Problems that the architecture was supposed to solve come back with a vengeance.

Outdated Code

AI frequently generates code relying on old library versions — unsupported ones or those containing critical vulnerabilities. Models were trained on data from a specific point in time and are unaware of new developments. Outdated code leads to low efficiency, poor integration, and security problems.

The prompt engineer fails to recognize the low quality of generated code because they've abandoned the understanding, experience, and erudition necessary to assess quality in the first place.

Part 3: Long-Term Business Consequences

AI enables rapid prototyping, idea validation, and user acquisition. However, successful projects grow, and this is where the bad code trap springs.

The problems of low-quality code are invisible in small projects but become critical at scale. By the time the problems manifest, the project already consists of a large volume of bad code, and halting the degradation is practically impossible.

The costs of developing new code and maintaining old code grow exponentially. Eventually, adding a new feature or fixing a bug becomes prohibitively expensive and time-consuming. The business loses competitiveness, customers, and ultimately goes bankrupt.

Conclusion

The author emphasizes that programmers are the most important link in the chain: result → code → programmers. Classical developers consciously prioritize process over speed, increasing their value.

Programming is first and foremost a thinking process. The author describes his own experience: long hours reading code without writing a single character, thinking not about how to make the code work but how to make it good. This process yields three results: satisfaction with the work, complete understanding, and the ability to defend decisions before colleagues.

The Key Insight

"In the near future, there will be a huge number of prototypes — they will grow and break. Demand for good programmers won't fall — someone is needed to solve the problems of bad code. The next decade is the golden era of classical programmers. AI filters out people who don't truly want to program."

Employers will be forced to address the problem of evaluating programmer competencies through stricter interviews, experience verification, and offline interview formats.

The Right Way to Use AI

• AI should automate only what the developer can easily do themselves, allowing them to validate results.
• When solving new problems, use AI as a reference for understanding rather than as a code generator.

Final thesis: "Programming is not about working code. Programming is about understanding."