Something genuinely new happened recently.
Not incrementally new. Categorically new. For the entire history of software, code was written by humans who understood, imperfectly, partially, but genuinely, what the code was doing and why. The understanding and the artifact were produced by the same process. You couldn’t fully separate them because the code was the residue of the understanding. It carried the marks of the decisions made, the alternatives rejected, the constraints navigated.
Then AI code generation arrived and separated them completely.
Now code appears without the understanding that would have produced it. The artifact exists. The residue is gone. What you have is output without process, syntax without commitment, form without the background that form was always previously inseparable from.
This is not a complaint about quality. AI generated code is often good. Sometimes excellent. It solves the stated problem, passes the tests, ships to production. By every visible metric it works.
The question Flores would ask is not whether it works. It’s what happens when it breaks.
Go back to video one. The hammer disappears into use. You develop a felt sense of it, weight, balance, the grain of the wood, the resistance that tells you something before conscious thought catches up. That felt sense is the background being built through accumulated breakdown. Through thousands of small failures that never rose to the level of crisis but each deposited something in the structure of your knowing.
Now consider what that process looks like in programming.
A developer writes code. It doesn’t work. They debug. The debugging requires them to hold the intended behavior, the actual behavior, and the gap between them simultaneously. To form hypotheses about where the gap lives. To navigate the structure of the code looking for the place where intention and execution diverged. Every debugging session is a breakdown that builds background. Deposits knowing. Makes the developer someone who has been inside this kind of failure and found their way out.
Do that ten thousand times across a career and you have a senior developer. Not someone who knows more facts. Someone whose background has been shaped by ten thousand breakdowns into something that functions like judgment. Like intuition. Like the ability to look at code and feel where the problem probably lives before the analysis confirms it.
AI generated code interrupts this sequence at the foundation.
The developer who uses AI to generate code they don’t fully understand never builds the background. The debugging sessions that would have been the curriculum don’t happen, or when they do happen, they happen without the interpretive framework that makes them generative. You’re debugging code you didn’t write, in a structure you didn’t choose, for reasons you don’t have access to, with no felt sense of the decisions that produced it.
It’s not that you can’t fix it. Sometimes you can. But you’re navigating without a map in territory you’ve never walked. And each time you defer to AI generation rather than building understanding, the territory gets larger and your map gets smaller.
This is the knowing gap. Not a gap in information. A gap in background. In the accumulated structural history that makes genuine debugging possible. That makes judgment possible. That makes you someone who knows rather than someone who has access.
And here’s where it becomes a systems problem rather than an individual one.
Organizations are now deploying AI generated codebases at scale. The humans nominally responsible for those codebases have backgrounds that were built in a different era, on different code, through different processes. The code they’re responsible for was generated by a system that has no background at all. And the junior developers who would normally be building their backgrounds through close contact with senior developers and real codebases are instead generating code through AI and wondering why they’re not developing the intuition they were promised would come with experience.
The knowing gap isn’t appearing at the individual level. It’s appearing at the organizational level. At the civilizational level. A growing body of consequential code that nobody fully understands, maintained by people whose background is insufficient to the task, generated by systems that cannot cope with their own breakdown.
Flores identified the mechanism in 1986. He called it the formalization trap. He said the trap catches the human as well as the system. He was right. He was just early.
This is not an argument against AI code generation. That would be like arguing against writing because it externalizes memory.
Writing did externalize memory. And something was lost, the oral tradition practitioners who could hold the Iliad in their heads, the mnemonic structures that shaped how knowledge was organized and transmitted. Something real disappeared. And writing was still the right move because what it enabled was worth what it cost, and because humans adapted their practices to compensate for what was lost.
The same calculus applies here. AI code generation enables things that couldn’t be enabled otherwise. The question isn’t whether to use it. The question is whether we’re honest about what it costs and deliberate about compensating for the loss.
What it costs is background. The knowing that develops through doing, failing, debugging, understanding. The felt sense that makes judgment possible. The structural history that makes a developer more than a code generator themselves.
What compensates for the loss is deliberate practice in exactly the territory AI makes it easiest to skip. Reading code you didn’t write and building understanding of why it’s structured as it is. Debugging without AI assistance until you find the problem. Building small things from scratch not because AI couldn’t build them but because the building is the curriculum.
Not as moral discipline. As a professional survival.
Because the knowing gap is already opening. And the developers who will matter most in five years are not the ones who generated the most code. They’re the ones who understood what they generated.
Flores would say, the background cannot be outsourced. It can only be built. Through time. Through breakdown. Through the ten thousand small failures that deposit knowing in a structure that was present for all of them.
The code is not the thing. The knowing is the thing. The code is just what knowing leaves behind.
@ Lee Greene