AI can write code. But neither you nor it understands what it's written. The reason has less to do with the code itself than with the medium where it runs.
Since the earliest days of programming, software development has followed a tight, repeatable, legible loop: write code, run code, inspect the result. Every major advance in tooling has fundamentally been about making that loop faster and more transparent.
Implicit within that process, so foundational as to be almost invisible, was the human engine starting it, writing it, and making it go. In modern AI development, vibey or otherwise, we no longer start by writing code. Humans start by describing intent and then watch as the system generates an implementation.
We know that the result is often something far more capable, and far more complex, than anything a person could have produced themselves. Less obvious is that it's also more complex than a person would produce if they could.
The code looks plausible. It runs. But with software, the question isn't only whether code works — it's whether it's right. And to answer that, as a developer you now have to read through logic you didn't write, trace variables you don't recognize, and rerun unfamiliar pieces of a system you didn't design, trying to answer questions as basic as: what is this doing, and why? Software is valuable when it is correct, trusted, and extensible. All three depend on comprehension.
AI increases the volume and velocity of code, but not its comprehension. Very often, it does the opposite.
This is the gap. The solution isn’t in the — it’s in the environment where code runs.
Today, most workflows treat execution as secondary — something that happens after the real work of generation is done. Code is produced in one place and run in another. Results come back, but intermediate state stays hidden. Interestingly, insidiously, the system behaves like a black box even when the code is fully visible. We have dramatically improved "write" without corresponding improvements to "run" and "inspect." When an agent can generate a thousand lines in thirty seconds, a once-manageable comprehension gap now opens at a scale no human review process can keep up with.
What this moment demands is an environment that can keep pace with generation — one that makes execution visible, exposes state as it changes, and supports rapid iteration between human and machine not after the fact but as the system builds. The loop that defined software development for decades — write, run, inspect — has to be restored, but at the speed and scale of machines rather than humans. Without that, we are simply moving faster toward the same opacity, generating more and understanding less.
Until then, AI will be an extraordinary way to produce code, but not extraordinary software.