Over the past few months, euphoria around "vibe coding" hasn't died down in professional communities and on social media. The concept paints an idyllic picture of the future: a programmer no longer needs to peer into lines of code, understand algorithms, or wrestle with syntax by hand. Just toss a spec or natural-language prompt into a coding agent's chat, and the neural network obligingly generates the implementation, writes tests, and verifies they pass. A popular slogan has even emerged: "Don't read the code, just trust the process."
At first glance, the temptation is huge. The speed at which prototypes appear is genuinely astonishing. Yet behind this outer gloss hides a serious engineering trap.
Well-known proponent of fundamental programming principles Timur Shemsedinov (HowProgrammingWorks) delivered a ruthless breakdown of this delusion in his talk "Don't read the code: the worst advice of the AI era" (the first part of the foundational "Architecture and AI" series). His main thesis is sobering: giving up thoughtful code reading is the most dangerous advice of the current tech wave, guaranteed to lead to an architectural collapse within a few months.
Code as the system's only formal contract
To understand the root of the problem, you have to ask yourself a simple question: what actually is software code?
Many treat code as a purely technical instruction for a compiler or virtual machine — some unavoidable low-level boilerplate they want to get rid of as soon as possible. That is a deep misconception. Source code is the only strict formal model of the system, capturing domain rules, edge-case handling, memory ownership, and failure behavior.
Natural human language is by nature diffuse, vague, and full of contextual assumptions. When you write in a prompt: "Build a subscription service and charge money once a month," you inevitably omit hundreds of invisible details. What should happen on a partial refund? How do you handle duplicate bank webhooks? Where are the transaction boundaries?
The neural network will generate code based on averaged probabilities from its training dataset. But if the developer doesn't read the resulting output, the system begins living a hidden life of its own. Refusing to read code means voluntarily giving up control over how the program actually executes the business task.
The illusion of mutual verification: why agentic review fails
Proponents of full AI autonomy often counter: "But we can spin up a second agent! Let one bot write the code, and a second bot acting as tech lead do the code review and reject bad solutions."
In theory, that sounds convincing. In practice, you run into the so-called AI self-verification fallacy.
Both models — generator and reviewer alike — were trained on the same source-code corpora and share the same probabilistic biases. Models excel at generating locally valid code: an individual function will be neatly formatted, supplied with pretty comments, and pass 95% of synthetic tests. Yet generative models are practically incapable of holding the global architectural context of a large repository spanning thousands of files.
The reviewer agent will happily approve a Pull Request because the function is syntactically spotless. What it won't notice is that the function secretly violated an abstraction layer boundary, queried another domain's database table directly bypassing the domain service, or introduced a hidden race condition in a multithreaded environment.
Degradation of architectural seams: hidden coupling
The real catastrophe of blind generation strikes not on day one, but after six months of active operation. In classic software architecture, the key health metrics of a codebase are low coupling and high cohesion. Every module should be responsible for one clear task and interact with the rest of the world through strictly defined interface contracts.
When an agent runs the codebase, module boundaries erode at an alarming pace:
- To close a ticket quickly, the model duplicates data structures in five different places instead of reusing a shared type.
- Side effects silently seep into the code: mutation of global variables, implicit dependencies on system timer state, uncontrolled filesystem calls.
- Architectural layers collapse into one another: controllers start running SQL queries directly, and date-formatting utilities suddenly fire off network requests.
The system rapidly turns into a fragile monolith of spaghetti code. Eventually a point of no return arrives: trying to fix a typo in the notifications module breaks shopping cart calculation on the opposite side of the project. The total cost of ownership (TCO) of such code skyrockets, and the team admits it's easier to rewrite the project from scratch.
Paradigm shift: from typing characters to analytical reading
Does Shemsedinov's critique mean we should throw away neural networks and go back to typing boilerplate by hand in Vim? Of course not. AI is a magnificent productivity multiplier when used with your eyes open.
A tectonic shift is simply happening in the software engineering profession:
- The skill of mechanical coding (rapidly typing boilerplate classes, loops, and data structures) really is losing value fast. Machines handle that better and faster than humans.
- The skill of deep analytical code reading, by contrast, is becoming an engineer's primary professional superpower.
A developer in the era of advanced coding agents and the fight against architectural erosion of systems, which we discussed in previous breakdowns, is no longer a bricklayer laying every brick by hand. They become the chief architect and a strict technical inspector.
An engineer must be able to scan a hundred generated lines and spot within thirty seconds: aha, here's quadratic $O(N^2)$ complexity out of nowhere, here a file descriptor close was missed, and this line breaks transaction isolation.
To protect your codebase from architectural erosion when working with agents, add architectural linters to CI (for example, dependency-cruiser for TypeScript/JavaScript or ArchUnit for Java). Lock down strict rules in configuration: the controller layer has no right to import the database layer directly. If an agent generates a bad import, the linter will block the build immediately.
A mature engineering balance
The practical takeaway is simple and pragmatic. Delegate grunt work to agents: generating test scaffolding, format parsing, routine migrations, and documentation. But never switch off your own critical thinking.
If you don't understand how every line of code committed to main works, you no longer control your product. True engineering maturity isn't about hitting the "Generate" button fastest — it's about spotting an architectural crack in time before the building collapses under load.

