AI Engineer World's Fair 2025
The Many Ends of Programming
Loading slides…
Read the talk
The Many Ends of Programming
AI can generate more code without resolving the hardest parts of software engineering. Six possible futures reveal where responsibility, reliability, and human choice still matter.
From a talk by Ray Myers
Before you start: Familiarity with source code, pull requests, and basic software maintenance will help; no Haskell experience is required.
Can we replace even one mainframe?
What would it take for AI to replace the software in even one mainframe? Ray Myers, introducing himself as chief architect at All Hands AI, maker of OpenHands, approaches that question as both an AI builder and a frequent skeptic. His starting point is empathy: the future of programming is difficult to discuss if the people building it cannot listen to one another.
The mainframe question was Myers’s response to a prediction by Anthropic CEO Dario Amodei. In the Council on Foreign Relations interview Myers cites, Amodei suggested that AI might write essentially all code within twelve months. Software engineers hear something narrower in that prediction than a general audience might: writing code is only part of the job. Myers proposed a friendly challenge—replace the software in one mainframe—to bring the discussion back to the difficulty of changing an existing system.
His recurring concern is that LLMs break old code. Maintaining working software already receives less attention than creating something new; in Myers’s view, the gap between AI’s ability to generate new code and its ability to edit existing code receives too little attention as well. A convincing account of software’s future has to include the systems we must keep alive, not just the programs we can now produce.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Getting past inevitability
Questions about limitations do not always receive technical answers. Myers describes being called a Luddite, told his head is in the sand, and accused of missing the big picture so completely that reading his post physically hurt. Those responses are unpleasant, but they also obscure the issue under discussion. Telling someone they will be left behind substitutes a threat for an explanation; to Myers, the phrase evokes the Kirk Cameron religious-apocalypse films more readily than a nuanced engineering conversation.
Another response, “Resistance is futile,” sends him to Star Trek. It is the Borg’s slogan, and the captured Picard speaks it as Locutus under their control. The Picard Myers admires stands for resisting in defense of truth. But following that analogy, Myers catches himself: he is now answering emotionally charged rhetoric with emotionally charged rhetoric of his own. It is not helping him listen. Having chosen to engage, he has a responsibility to hear people out and make the exchange productive.
There is a substantial shared question underneath the conflict: what can we make the future of software become? AI has brought people into a common conversation about the craft, even when they disagree about its destination. Myers separates that conversation into six scenarios: extreme completion, devocalypse, abstraction leap, uncharted waters, the review economy, and the infinite pile of garbage. They describe different mechanisms and outcomes, rather than six mutually exclusive predictions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Extreme completion: more work within an engineer’s control
Extreme completion is the most conservative scenario because it already exists. Cursor and GitHub Copilot help engineers do more of the typing. The open questions concern how far that assistance will go and what impact it will have. Even an agent that performs several steps can remain closely supervised, leaving the engineer’s underlying responsibility largely intact.
The editor demonstration makes that boundary concrete. In Cursor, a VS Code fork, Myers uses Control+K to open an inline prompt. An existing Haskell function, cleanPrime, removes trailing whitespace. He asks for cleanPrimePrime, which should remove both leading and trailing whitespace, and Cursor generates another function from the example. The demonstrated transformation can be expressed in Haskell as follows:
haskell
import Data.Char (isSpace)
cleanPrime :: String -> String
cleanPrime = reverse . dropWhile isSpace . reverse
cleanPrimePrime :: String -> String
cleanPrimePrime = dropWhile isSpace . cleanPrime
example :: (String, String)
example =
( cleanPrime " hello "
, cleanPrimePrime " hello "
)
-- (" hello", "hello")
Reversing the string lets dropWhile remove what was originally trailing whitespace; reversing again restores the remaining text’s order. The second function additionally drops whitespace from the front.
Haskell is a deliberate choice. Myers sees its strong type system, and type theory more broadly, as a promising source of certainty around uncertain LLM generation. Types can constrain the shape of acceptable programs before someone reviews them. They do not, by themselves, establish that a function with type String -> String implements the intended whitespace behavior; the useful direction is to add machine-checkable constraints around generation.
A second demonstration moves from the editor to an experimental Slack interface for OpenHands. Myers points the agent at an existing pull request where he has added information to a log statement, then asks it to find other places that need the same addition and open a new pull request. Myers reports that the experimental Slack workflow returned a 48-file pull request a few minutes after he delegated the logging task.
That is a substantial amount of grunt work to delegate. It is also a bounded task: a person supplies the example, identifies the intended change, and retains the expertise needed to judge where it belongs. Myers treats this as extreme completion too. The agent can shovel through technical debt without demonstrating that it can independently own the surrounding system.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Devocalypse or innovator’s paradise?
The devocalypse goes much further: people no longer depend on software developers to turn ideas into working software. From a developer’s perspective, that can look like an apocalypse. From the perspective of someone waiting for developers to build an idea, it looks like an innovator’s paradise. The same capability has very different meanings depending on who currently bears the dependency.
Myers considers a feasible version desirable. Removing that dependency could represent programming fulfilling its purpose, even finishing the project of computer science. The important objection is therefore feasibility: can the proposed approach actually deliver and sustain the promised software? He acknowledges wanting his friends to keep their jobs, while rejecting the idea that every engineering objection is merely job protection. A prediction of developer replacement needs a mechanism for getting there. Expertise about unsustainable systems remains relevant to evaluating that mechanism.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Abstraction leap: can prompts become the source?
An abstraction leap offers one possible mechanism. Today’s Java or Rust could become tomorrow’s assembly language, JVM bytecode, or LLVM bitcode: still present underneath the system, but manipulated directly mainly by specialists. Most people would work through a higher-level representation that is more pleasant and productive. The underlying computation would remain recognizably code-like.
In the prompts-as-code version, natural language becomes the principal artifact humans edit. Scaling beyond a single prompt might mean organizing small requirements into interconnected folders and supplying tests. The hard question is whether this constitutes a dependable abstraction. If changes have unpredictable effects, a team may be unable to compose the pieces into a large, long-lived system. More structure or additional controls might compensate, but that reliability has to be demonstrated.
Parsel supplies a concrete example of the idea. Myers describes a Parsel example in which 61 lines of structured prompts and example inputs and outputs generate a 220-line Python Lisp interpreter. The specification describes multiple functions, while examples constrain what those functions should do. This is a more structured relationship between intent and implementation than a single open-ended request.
Producing an interpreter is an impressive demonstration, but operationalizing the approach introduces another question: can structured prompts become the basis of a real product that is better than its alternatives? Myers regards that as unresolved. The existence of a successful generated program does not settle how a prompt-based source representation behaves as requirements and implementations evolve.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A specialized language can make the leap smaller
Myers finds domain-specific languages, or DSLs, a more promising route. They are already familiar: CSS expresses page styling, SQL expresses queries, and regular expressions express text patterns. Other languages target business domains; even Excel can be understood this way. Instead of asking a general-purpose language to express everything, a DSL makes the recurring ideas of a particular domain easier to state.
An organization adopting this approach invests in a specialized programming environment. That upfront cost can pay back through reliability, quality, and productivity because the environment is designed around what its users usually need to express. It can also backfire. Myers describes the trade-off as improving over the preceding two decades as tooling has made these environments easier to create.
The tooling landscape includes JetBrains MPS, Xtext, and LionWeb, with LionWeb more precisely serving as an interoperability initiative for language-oriented modeling components and specifications. Racket belongs in the discussion as a Lisp dialect and language-oriented programming environment. These are different ways to support specialized languages, rather than interchangeable products.
Language models could improve the economics on both sides of a DSL:
- Building the environment: Generate some of the implementation code that processes the specialized language.
- Using the environment: Offer editor suggestions that help business-domain users learn and express themselves in it.
In this arrangement, AI assistance can make a structured language easier to build and easier to navigate, without requiring natural-language prompts themselves to become a predictable programming substrate.
Myers has made this a focus of his Craft vs. Cruft channel, declaring a year of DSLs, and recommends Markus Voelter’s talk Empowerment of Subject Matter Experts for a deeper exploration. The defining boundary remains the same: beneath this abstraction, the system still follows familiar computational rules.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What if computation stops being code-like?
Uncharted waters names a more radical possibility: the foundation itself changes. Myers distinguishes two versions:
- Direct model inference: Models act like processors, with inference becoming computation itself, rather than models merely appearing inside programs or generating their source code.
- AI-invented paradigms: A superintelligent system develops a way of programming that we cannot presently conceive.
Both move beyond the abstraction-leap scenario, which retains conventional code underneath a new human-facing layer.
Possibility alone does not provide a planning method. To plan around these futures, engineers must discover what works and what scales—in effect, chart the waters. Myers does not consider either possibility to have proved itself at the time of the talk.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
When generation outruns review
The review economy returns to a familiar workflow. Extreme completion makes pull requests cheap to produce, but their output is not reliable enough to approve automatically. Humans remain responsible for checking it. The logging pull request illustrates the upstream capability; this scenario asks what happens when a team receives more such changes than it can confidently evaluate. For developers who already find review the least enjoyable part of the job, making it the entire job is a dismal prospect.
Myers has seen versions of this situation in companies, but considers it a possible pit stop rather than an inevitable end state. It is a bottleneck-management problem. Eli Goldratt’s theory of constraints, introduced through The Goal, offers a body of thinking for systems held back by one choke point. Here, that constraint is manual developer review. Producing more work upstream does not remove it.
Two interventions address different causes of the queue:
- Prevent errors earlier: Shift checks left, including the type-theoretic controls discussed in the Haskell example, to reduce the burden placed on later review.
- Prioritize what deserves review: Select the changes with the greatest value instead of treating every generated pull request as equally worth shipping.
Myers illustrates prioritization with a hypothetical: shipping one-third of the items could deliver 90% of the value if the team chooses the right items. The point is to manage useful output through the constraint, rather than maximize the volume waiting in front of it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The infinite pile of garbage
The final scenario is worse than a review queue. In the infinite pile of garbage, coding assistance makes developers feel more productive while accumulating technical debt faster than they can manage it. Eventually, even AI cannot dig the system out. Products deteriorate instead of improving. This is a failure of the resulting software, regardless of how quickly its code was written.
Uplevel’s investigation of coding-assistant adoption provides one warning. Myers cites Uplevel as finding a higher bug rate with coding-assistant access and no throughput improvement. The study announcement describes a controlled observational comparison using matched groups and measurements before and after adoption; it does not state random assignment. Its efficiency measures concern pull-request throughput and cycle time, rather than issue throughput.
GitClear’s code-quality report supplies a different warning. Myers reports that 2024 was the first year in GitClear’s observed dataset when the share of copy-pasted code exceeded the share of moved code. Moved code serves as a proxy for refactoring, so the crossover raises a maintenance concern: repeated code can create more places where a future change must be made consistently. The observational trend does not isolate AI as the cause. If AI changes the usual relationship between duplication and maintenance risk, Myers argues that the new relationship still needs evidence.
GitHub’s Does GitHub Copilot improve code quality? points in the opposite direction. Myers cites GitHub as finding improved code quality with Copilot in a controlled experiment on a fixed task. That task-based result differs from the real-work observations discussed earlier; it does not directly answer what happens to long-term maintenance or production defects. Differences in task, setting, and outcome measures matter when interpreting the apparent contradiction.
Myers also points out that all three sources have something to sell. His preferred next step is stronger independent evidence, ideally a meta-analysis of multiple academic studies examining results in the wild. The useful questions are conditional: which uses improve outcomes, which worsen them, and how much depends on the task or the way a team uses the assistant? Better models do not automatically produce better products. Improving the products requires deliberate choices about what to build and how to build it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The scenarios can combine
These futures interact. A team might invest heavily in extreme completion, aiming to remove its dependence on developers, before it can handle the output. The intended destination is devocalypse; the actual destination could be the infinite pile of garbage. Increasing generation capability without developing the capacity to maintain its results can change which scenario unfolds.
Myers’s preferred direction combines extreme completion with an abstraction leap: a well-designed DSL, or a specification system grounded in formal methods, supplies structure while AI assistance makes it easier to navigate. The structured environment constrains what can be expressed; the assistant improves the ergonomics of expressing it. That combination connects the earlier interest in type theory with the economics of specialized languages.
There need not be one winner across the entire industry. Several endgames can occur at once, and two people predicting different outcomes may both be right about their own domains. Video game programming and healthcare technology should not be expected to experience identical effects. Their futures can diverge even while using related tools.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
We get a say
AI coding is sometimes described as a meteor arriving from outside the solar system while everyone watches helplessly. Myers rejects that picture. People are actively building these tools and the systems around them. We therefore have a say in what happens—and need to decide what we want from software.
Wanting no one to be a programmer is different from wanting everyone to be able to program. Wanting higher-quality software is different from wanting more software regardless of quality. Those goals can lead to different engineering and organizational decisions, even when both are described as progress.
The same choice applies to people whose required skills change. An organization can discard workers who diligently learned what it needed yesterday, or it can find ways to continue developing valuable relationships with them. Myers closes with a goal that includes both the artifact and the people around it: software should work well, provide value to its users and builders, and be made by people who treat one another well.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Public repository for the OpenHands coding-agent project.
Tools for creating domain-specific languages with projectional editors and integrated editor assistance.
Specifications and components for interoperable language-oriented modeling tools on the web.
A language-oriented programming environment with macros, DSL-building facilities, contracts, and optional typing.
Study announcement reporting bug-rate and pull-request efficiency findings from 800 developers before and after Copilot adoption.
February 2025 report examining code-change patterns across 211 million changed lines from 2020–2024.
Full transcript
Loading transcript…