Code Is Now Cheap. Understanding Is Not.

In April, the Washington Post asked whether AI is to blame for the disappearance of computer science majors. The numbers behind the question are stark: enrollment in computer and information science programs fell 8.1 percent in the 2025–2026 school year — the steepest decline of any field of study, according to National Student Clearinghouse data — the biggest drop for any major in six years. Students and their parents have looked at coding agents that write working software from a paragraph of English and drawn the obvious conclusion: why spend four years learning something a model does in four minutes?

The obvious conclusion is wrong. Not slightly wrong — inverted. The evidence accumulating through the first half of 2026 points the other way: AI has made code nearly free while making understanding the scarcest resource in software. And understanding — the ability to decompose a problem, choose an abstraction, reason about state and failure, and evaluate whether a solution actually solves the problem — has a name. It is computational thinking, and it has never been worth more.

The year the bill arrived

2025 was the year of vibe coding euphoria. 2026 is the year of the invoice.

Start with the defect data. In December, CodeRabbit published its State of AI vs. Human Code Generation report, an analysis of 470 real-world open-source pull requests. AI-co-authored PRs contained roughly 1.7x more issues than human-only PRs — 10.83 issues per PR versus 6.45 — with logic and correctness errors up 75 percent, security vulnerabilities up 1.5–2x, and performance inefficiencies appearing nearly eight times as often. The code compiled. The tests passed. The problems were the kind you only catch if you understand what the code is supposed to do.

Then came the naming of the disease. In March, Google engineering leader Addy Osmani published his essay on comprehension debt — the widening gap between how much code exists in a system and how much of it any human genuinely understands. Unlike classical technical debt, comprehension debt is invisible: nothing is slow, nothing is broken, the dashboards are green. It surfaces only when something fails and nobody on the team can form a mental model of the system fast enough to fix it. Teams merge dramatically more pull requests, review them for longer, and ship more incidents.

Industry observers have stopped being polite about where this leads. The New Stack warned that unreviewed AI code in production could cause catastrophic “explosions” in 2026, invoking the Challenger disaster as the analogy of choice: organizations normalizing deviance one merged-but-not-understood PR at a time.

The wrong lesson and the right one

The vibe coding backlash has produced two camps, and both are misreading the moment.

Camp one says the enrollment collapse is rational: coding is over, so computing education is over. This confuses the artifact with the discipline. What AI automated is the translation step — from a precise mental model to syntax. It did not automate the construction of the mental model. Every failure mode documented this year — the logic errors CodeRabbit measured, the comprehension debt Osmani described, the 80/20 wall where AI-built projects stall on edge cases and integration — is a failure of modeling, not of typing. The last 20 percent of every project is pure computational thinking: identifying the edge cases (decomposition), recognizing which invariants the generated code silently violated (abstraction), and constructing the test that would expose the difference (evaluation).

Camp two — the backlash purists — says the answer is to reject the tools and return to hand-craftsmanship. This is equally untenable. The productivity gains are real for well-scoped work, and no employer will pay for artisanal boilerplate. Researchers describing the democratization of computational thinking have it right: large language models have decoupled computational problem-solving from direct programming. That decoupling is not a threat to computational thinking. It is the strongest argument ever made for teaching it separately from — and prior to — syntax, because for the first time, people who will never write a for-loop are nonetheless directing computational processes and inheriting their failure modes.

Here is the position this site will defend: computational thinking has become a verification discipline. For thirty years we taught CT primarily as a generative skill — decompose the problem so you can build the solution. In 2026, the generative half is shared with machines. What cannot be delegated is the evaluative half: specifying precisely what “correct” means, predicting how a system fails, and auditing an artifact you did not write. A developer who delegates code generation but retains specification and verification is doing more computational thinking than the 2019 developer who typed everything by hand, because they must hold the model of the system in their head without the scaffolding of having built it line by line. Studies are already showing the cost of skipping this: developers who delegate to AI score about 17 percent lower on comprehension tests of the resulting code. That gap — between shipping and understanding — is exactly the gap CT education must now close.

What this means in practice

For educators. Stop treating the enrollment drop as demand disappearing; it is demand relocating. The market signal is not “don’t learn computing” — it is “don’t learn only syntax.” Curricula should invert the classic sequence: lead with specification, decomposition, testing, and debugging-by-hypothesis, and treat code generation (by hand or by agent) as the cheap step it now is. Reading and critiquing code — including AI-generated code with planted defects — deserves as many contact hours as writing it. A student who can look at a plausible-but-wrong function and articulate why it is wrong has a skill no agent commoditizes.

For practitioners. Treat comprehension as a budget line. If your team merges AI-generated code, the review is no longer a courtesy pass — it is the moment the team either purchases understanding or takes on comprehension debt at compound interest. Concrete habits that pay: require the PR author to explain the change’s failure modes in their own words; keep architectural decisions and invariants in human-written documents the agent must conform to, not the reverse; and measure “time to correct diagnosis” in incidents, because that is the metric comprehension debt silently destroys.

For students weighing the major. The 6.1 percent unemployment rate for recent CS graduates is real, and so is the hiring pullback for juniors whose only offering is code production. But notice who is not struggling: people who can own a problem end to end — frame it, direct machine labor at it, and certify the result. That profile is a computational thinker with tools, and it is becoming the default job description across engineering, science, and operations, not just software.

Takeaways

1. Code generation is commoditized; correctness judgment is not. The 2026 defect and comprehension-debt data show quality failures concentrated exactly where human modeling was skipped.
2. The CS enrollment collapse answers the wrong question. The market is repricing syntax fluency, not computational thinking — the two were only ever bundled by historical accident.
3. Teach and practice CT as verification. Specification, failure prediction, and code reading are the durable skills; make them first-class in curricula and code review.
4. Account for understanding explicitly. Every AI-generated merge either buys comprehension or borrows against it. Only teams that track the difference will find out before the outage.

The machines learned to write code. They did not learn to know what we meant. Closing that gap was always the hard part of computing — we just used to hide it inside the typing.