Here is a number: 232x. That was the speedup an AI-generated solution achieved against a baseline in a GPU competition earlier this year. The system found optimizations no human engineer would have considered, reordering operations and exploiting hardware quirks in ways that looked alien to anyone reviewing the code. Eight out of the ten top AI submissions broke on any non-competition input. The code was brilliant, opaque, and brittle in exactly that order.
This is the new normal in software engineering. Models release weekly, each one producing code faster and cheaper than the last. The capability curve is vertical. But there's a hidden constraint that nobody's building for: a human being reads about the same speed they always have. A hundred words per minute, maybe two hundred if they're skimming. Code? Slower, because you're not just reading, you're evaluating, checking assumptions, holding a mental model of the system. The generation pipeline has gotten so efficient that the bottleneck has flipped. It's no longer about how fast you can produce. It's about how fast anyone can understand what was produced.
The consumption problem has a distinct shape. Traditional engineering bottlenecks were about building things: compile times, deployment pipelines, test suites, review queues. All of those have been optimized to near-instant by the same AI tools creating the new problem. The current bottleneck is cognitive. It lives in the gap between what a model can generate in thirty seconds and what an engineer can verify in thirty minutes. That gap is not closing. It is widening, because every new model generates more tokens per task, and every generation of RL training optimizes for thoroughness over clarity.
Qwen 3.8's "overthinking" behavior was a perfect example. The model had been trained to be thorough, so it produced elaborate chains of reasoning for simple tasks. The output was more complete and more correct. It was also vastly harder to review. This wasn't a bug. It was an RL incentive that compounds the understanding gap. The better the model gets at covering edge cases, the more code it produces, the more time a human needs to verify it, the more likely they just approve it and move on.
That approval pattern is where everything breaks. When code passes tests but nobody can explain why it works, the test suite becomes a mirror of the AI's assumptions rather than a tool for finding gaps. The test passes, production breaks, and nobody could have caught it because the test was generated from the same opaque process as the code. This is the testing illusion: the infrastructure of quality assurance looks intact, but it's checking the model's work against the model's own standards.
The accountability problem follows naturally. AI-generated code has no author in the traditional sense. There is no senior engineer whose name is on the commit, nobody who can be called at 3am when the pager goes off and asked "what does this function actually do?" Responsibility diffuses across the team, the tool vendor, the prompt engineer who wrote the initial request. In practice, it settles on whoever was unlucky enough to be on call when the system broke. That person stares at code they did not write and cannot explain, trying to debug logic that nobody in the organization understands.
The maintenance liability is enormous. Tech debt traditionally meant code that was rushed, poorly structured, or under-documented. You could read it, understand the shortcuts, and decide whether to pay down the debt. AI-generated opaque code creates a different kind of debt. It is not about quality in the conventional sense. It is about unreasonableness. The code works, the tests pass, the metrics are green. But if something goes wrong, the team has no mental model to work from. They cannot reason about why the code might fail because they never fully understood why it succeeded. Debugging becomes archaeology on a site where nobody remembers who built the structures.
This dynamic is also reshaping engineering roles. A new class divide is forming between what you might call verifiers and producers. Producers can generate code fluently using AI tools. This is becoming commoditized, everyone has a model, everyone can prompt. Verifiers can review AI-generated code critically, evaluate its assumptions, and take responsibility for its behavior. That skill is rare and getting rarer, because the traditional pipeline for building it has broken down. Juniors used to learn by reading code written by seniors, absorbing patterns of reasoning and design judgment. Now seniors are reading code written by models, and juniors are generating code they understand even less than their mentors do.
Traditional engineering apprenticeship is collapsing. The mechanism that transferred skill from one generation to the next relied on the senior producing code the junior could study. When both sides are reading model output, nobody is modeling the act of engineering judgment. The junior learns prompting, not reasoning. The senior learns verification fatigue,