AI coding may lead to several different futures, from engineer-supervised autocomplete to software built on abstractions that no longer look like code.
2
Prompt-based programming is still too unpredictable for Myers to treat as a proven foundation, while domain-specific languages offer a more established path to specialized programming environments.
3
Cheap generated code can create a review bottleneck or an infinite pile of technical debt, so teams need evidence and deliberate choices about quality, tools, and work.
Summary
Ray Myers frames AI programming as a disagreement about the future of software, with empathy needed alongside technical judgment. He names six possible endgames: extreme completion, the developer apocalypse, the abstraction leap, uncharted waters, the review economy, and the infinite pile of garbage. Each describes a different answer to who builds software and what counts as programming. Myers accepts that autocomplete and agent-assisted grunt work are already spreading, but he questions whether prompts can become a dependable foundation for large, long-lived systems. He is more hopeful about domain-specific languages, especially when AI lowers the cost of building specialized environments. He also warns that cheap pull requests can make review the whole job, while coding assistance can increase bugs and technical debt. The talk ends with a choice: people are building this future together, so they must decide whether they want more software, better software, or a healthier relationship between software and the people who make it.
AI coding arguments need listening before prediction
Myers begins with the reactions he gets when he questions claims such as Dario Amodei's suggestion that AI could write essentially all code within 12 months. He argues that software engineering includes more than producing new code, especially maintaining old code. In his experience, large language models perform much better on new code than on editing existing systems, and they can break old code. He has been called a liar, accused of having his head in the sand, and told he will be left behind. His response is that emotionally charged language makes it harder to hear people who may mean well. The underlying question is worth separating from the rhetoric: what should the future of software look like?
Extreme completion adds more automation without changing the engineer's role
Extreme completion is Myers's most conservative scenario because it is already happening. Tools such as Cursor and GitHub Copilot help with more of the typing, while agents take on somewhat longer tasks under an engineer's supervision. He shows Cursor changing a Haskell function so it removes both leading and trailing whitespace, then shows an OpenHands agent receiving a task through Slack and returning a pull request touching 48 files. Myers calls this an all-purpose technical-debt dirt shoveler. The task is useful and removes grunt work, but it remains on a short leash and still depends on substantial expertise. In this endgame, the engineer's job does not fundamentally change.
The developer apocalypse would fulfill programming's original promise if it were feasible
In the developer apocalypse, software developers are no longer needed to turn other people's ideas into working software. People who depend on developers may see this as an innovators' paradise rather than an apocalypse. Myers says that if this outcome were genuinely possible, it would be desirable because it would fulfill programming's destiny and finish the project of computer science. His objection is about feasibility and sustainability, not the goal itself. He also admits that he wants his friends to keep their jobs. That personal interest does not explain all his technical criticism, because software engineers have real expertise about what current systems can and cannot sustain.
An abstraction leap could move most programming above today's code
The abstraction leap predicts that Java, Rust, or similar code will eventually occupy a position like assembly language, JVM bytecode, or LLVM bitcode does today. Most people would work at a higher level while specialists maintained the underlying machinery. One version makes natural-language prompts the main human-facing artifact. Myers doubts that prompts are yet a dependable abstraction because their behavior is unpredictable. He discusses the Parcel paper, where 61 lines of prompts and examples generated a 220-line Python Lisp interpreter, but says structured prompts are not a solved way to build real applications. Domain-specific languages seem more promising. CSS, SQL, regular expressions, and Excel show how specialized languages can support reliable work in particular domains.
Uncharted waters would replace code with a computational foundation we do not yet understand
The uncharted-waters scenario goes beyond moving to a higher level of code. Its foundation might not be code-like at all. Myers describes direct model inference, where language models become the processors and model inference becomes the new computation. Another possibility is that a superintelligent AI invents a programming paradigm humans cannot currently conceive. He does not dismiss these outcomes, but he says they cannot guide planning until people chart them through working examples and evidence about scale. So far, he has not seen such a future prove itself. The name of the scenario captures the problem: prediction is easy when the underlying system has not yet been mapped.
The review economy turns generated pull requests into a bottleneck
When AI makes pull requests cheap but still requires people to check them, the review economy emerges. Developers may spend their entire time reading output from coding agents, which Myers describes as a depressing possibility because the least enjoyable part of the job becomes the whole job. He sees this as a possible pit stop rather than a final state. He applies the theory of constraints, associated with Eliyahu Goldratt and The Goal, to the problem. Teams can reduce the error rate with tools such as type theory, review fewer generated changes, or prioritize the changes that bring the most value. Shipping a third of the items could produce 90 percent of the value if selection is good.
Unchecked coding assistance can create an infinite pile of garbage
The most dismal scenario is a system where coding assistance makes teams feel productive while increasing technical debt and lowering product quality. Myers cites an investigation by Uplevel that found developers with access to a coding assistant produced a significantly higher bug rate without better issue throughput. He also cites GetClear's finding that in 2024, copy-pasted code exceeded code moved during refactoring, which he calls a red flag. GitHub reported the opposite result for Copilot, finding improved quality in a controlled experiment with a fixed task. Myers treats the results as contradictory and limited because the sources have something to sell. He wants independent academic work, ideally a meta-analysis, to show when these tools help and when they make things worse.
Different endgames may happen in different parts of the industry
Myers does not expect one scenario to govern all software. Extreme completion could push teams toward the developer apocalypse, or teams could overinvest before they can manage the output and slide into an infinite pile of garbage. He sees a promising combination in domain-specific languages or formal-methods-based specifications paired with extreme completion. The industries are also too varied for one prediction to fit everywhere. AI coding could affect video-game programming differently from healthcare technology. Myers's final point is that this future is being built by people rather than arriving like a meteor. Teams can decide what they want from software, including whether they want fewer programmers or more people able to program, and whether quality matters alongside quantity.
"We get a say on what happens. This is something that we are actively building together."25:00
Who should watch
You are deciding whether AI coding tools should be used for new features, maintenance, or technical-debt work, and need a map of the possible outcomes.
Your team is generating more pull requests than it can review, or you are worried that faster coding is increasing bugs and copy-paste code.
You are exploring domain-specific languages, formal methods, or higher-level specifications as a way to make AI-generated software easier to control.
