The New York Times recently ran a long feature with a dramatic headline declaring the end of computer programming as we know it. The article describes developers at Google, Amazon, startups and elsewhere who now spend their days talking to AI agents instead of writing code by hand. Some barely type at all. They describe what they want, review a plan, approve it, and the machines do the rest.
If you learned to code in the old days, this sounds somewhere between science fiction and heresy.
The piece follows engineers who once measured progress in painstaking increments. A good day might produce a few dozen lines of production code after hours of thinking, debugging, testing and rewriting. That was not laziness. That was reality. Every line had consequences. Every change could break something critical. Careful work was the job.
Now those same engineers can generate thousands of lines in minutes. Entire features appear before lunch. Systems that once took weeks can be assembled in hours. One founder quoted in the article says productivity gains feel like ten to one, twenty to one, even a hundred to one.
That part is not hype. Anyone actually using these tools knows it is real.
But the article frames this as the end of programming. That is not quite right. Programming is not disappearing. It is being industrialized.
We have seen this movie before.
Assembly gave way to higher-level languages. Manual memory management gave way to garbage collection. Libraries replaced handwritten routines. Open source replaced writing everything from scratch. Each step removed drudgery and raised abstraction. Each time, old hands warned that real programming was dying. Each time, software kept getting bigger, more complex and more important.
AI is not another step on that ladder. It is an elevator.
Code production is no longer constrained by human typing speed or cognitive bandwidth. Machines can produce far more code than any team of humans ever could. The marginal cost of trying an idea approaches zero. If something does not work, you throw it away and generate another version.
Scarcity is gone.
And when scarcity disappears, behavior changes everywhere.
Startups can build products with tiny teams. Enterprises can modernize ancient systems faster. Individuals with no formal training can create software that once required a full department. The Times article even describes a print shop manager who built a working application without understanding the code it produced.
That is not the end of programming. That is the democratization of it.
But there is a catch. Software is not valuable because code exists. It is valuable because systems behave correctly, reliably and securely over time. AI can generate code far faster than humans can understand, validate, integrate or maintain it.
So the bottleneck moves.
For decades, the limiting factor in software development was producing code. Now the limiting factor is controlling what that code does once it exists.
Welcome to the governance era.
Engineers are becoming supervisors of automated production. The job is shifting from writing instructions to defining constraints. Instead of crafting every line, developers decide what should exist, what must never exist, what risks are acceptable, how systems fit together and how failures are contained.
In other words, less construction worker, more building inspector.
Large companies already live in this world. In mature codebases, engineers spend much of their time reviewing changes, managing dependencies, planning releases and responding to incidents. The Times article notes that even at Google, where AI is deeply integrated, productivity gains are meaningful but not explosive because safety and integration still dominate. You cannot just spray new code into systems that billions of people rely on.
Startups, on the other hand, are in greenfield territory. Fewer constraints, fewer legacy systems, lower blast radius. That is why they are seeing the wild gains.
But even there, cheap code can create expensive problems. Technical debt accumulates faster. Security vulnerabilities multiply. Systems become harder to reason about. Velocity can outrun understanding.
Cheap code is like cheap plastic. Useful everywhere, dangerous in bulk.
There is also a human dimension the article touches on but does not fully explore. Junior engineers traditionally learned by doing the tedious work. Writing tests. Fixing small bugs. Implementing well-defined features. That apprenticeship path built intuition. If AI handles that work first, where does the next generation gain experience?
We may be trading short-term productivity for long-term expertise.
None of this means programmers are obsolete. If anything, experienced engineers become more valuable. When machines produce endless output, judgment becomes the scarce resource. Knowing what to build, what to ignore, what will fail in production and what will age well matters more than ever.
The new elite skill is not typing code. It is steering complexity.
For years, we told young people to learn to code. That was good advice in a world where code production was the bottleneck. In the emerging world, the better advice might be to learn systems thinking, architecture, security, operations and critical evaluation. The machines can generate syntax. They cannot take responsibility.
The Times article describes developers who feel both exhilarated and uneasy. That mix is telling. They sense they have been handed enormous power without clear rules for using it. Productivity gains feel intoxicating, but the long-term implications are murky.
This is not the end of programming as we know it. It is the end of programming as manual labor.
Software development is becoming less about making code and more about managing the consequences of code. The organizations that thrive will not be the ones that generate the most lines. They will be the ones that keep systems stable, secure and comprehensible despite the flood.
When code becomes cheap, engineering becomes governance.
And governance, unlike typing, cannot be automated away.