When rebuilding software costs nothing

This week the internet was full of game mashups: Mario physics in Elden Ring, Minecraft mechanics in Pokémon, the board from Skate (speed glitch included) running inside Modern Warfare. Atrioc’s video Everything Is Everything Now is a good non-technical explanation of how they were made, and it got me to write down where I think this leads.

I’ve been working on the same questions for a few years, mostly from the research side: in the SymbolicAI framework we started in 2022, in a paper and my doctoral thesis in 2024, in a few interviews, and two months ago in an essay on where the value of software goes. Here I try to put my current view in one place, with dates and sources throughout, so you can check the claims and see how the thinking developed.

One disclosure up front: I build AI agent systems for a living, so I’m not a neutral observer here. That’s one more reason I’ve linked the evidence wherever I could.

Roughly, I’ll argue five things:

1. What changed this month is how much effort it takes to reverse-engineer software. Encryption still works. But anything that was only protected because reversing it took years is now exposed, at least where a result can be checked automatically.
2. Rewriting a decompiled game in Rust is impressive, but the result is still a normal program that someone ships. I think the bigger change comes later, when an application is put together at the moment you ask for it and discarded afterwards. In our 2024 paper we called this Software 3.0.
3. The generate-and-check loop that decompiles a game can also be pointed at AI systems themselves. Wherever a cheap check exists, that loop improves quickly, which is why I think the next two to five years matter so much.
4. Software is probably just the first area where this happens. Other knowledge work follows, and so does media: music already, with video and games likely arriving together, made more like 3D productions than like generated pixels.
5. A few things keep their value: accountability, rights enforced by law, ecosystems, physical assets and relationships. The list is shorter than I’d like, and some of the consequences worry me.

What changed this month

The mashups come in two kinds. Many of the viral clips are a clever trick: two games run side by side and share memory, and one character is drawn over the other. Nothing gets rebuilt. The others come from decompilation, which means going from the shipped machine code back to readable source code. People then take a system out (the parkour, the climbing, the skate physics), rewrite it, usually in Rust, and put it into a different game. The same wave produced a browser version of Halo: Combat Evolved, which The Verge covered this week, and Windows Central notes that “these projects are largely driven by AI-powered tools”.

Decompilation used to be slow, careful work. A person writes a guess at the source code, compiles it, compares the bytes with the original, adjusts the guess and repeats, function by function, often for years. That effort was the protection.

A lot of software relied on it: games, desktop programs, mobile apps, anything running on a machine the customer controls. Nobody had shown that reversing them was impossible. It just wasn’t worth anyone’s time. Now that the effort is mostly gone, almost any program that runs on your own computer can be taken apart and rewritten in another language.

This doesn’t break cryptography, and I don’t think banks or encrypted communication are suddenly exposed. Security people adapt, and protection that rests on mathematics isn’t affected. What’s under pressure is protection that depended on cost.

Why checkable tasks change first

Decompilation became fast because the result can be checked automatically. The checker is a compiler, and the test is whether the output matches the original byte for byte. There’s no taste involved and no ambiguity, and the checker never gets tired. Generate a candidate, compile, compare, fix, repeat. A loop like that doesn’t have to be clever, as long as it’s fast and can tell when it’s wrong, and current models can do both.

This is a general pattern. Jason Wei, known for chain-of-thought prompting, calls it the verifier’s rule: “The ease of training AI to solve a task is proportional to how verifiable the task is.” Theo Browne made the same point about compilers in a video last month: “compilers are easier here because you have verifiable inputs and outputs.”

I made a similar point in The moat was never the software: what got cheap is software that can be described precisely enough to regenerate and checked cheaply enough to correct. I tested that by building a streaming app in six days. Decompilation is an even cleaner test, because the binary itself is the specification and checking it costs almost nothing.

Most of the rest of this post follows from that observation: which work changes first, how quickly the systems improve, and what keeps its value.

Software 3.0: applications that exist while you need them

A rewritten game is still a game that someone built, shipped and runs. The tools have changed, but the way software reaches people hasn’t, at least not yet.

That second part is what I’ve been working on. In the SymbolicAI paper, first posted in February 2024 and published at CoLLAs 2024, we wrote:

We refer to the next generation of software as Software 3.0, which consists of applications that are neither pre-determined at design time, nor learned through statistical inference, but triggered by an interaction which stimulates the realization of a computational graph […] purely established at inference time in the “thought” process of a NeSy system.

Dinu et al., SymbolicAI: A Framework for Logic-Based Approaches Combining Generative Models and Solvers, CoLLAs 2024, Appendix A

The same passage is in my doctoral thesis (JKU, 2024), and this is the figure that goes with it:

Figure 8 from the SymbolicAI paper (CoLLAs 2024). Software 1.0 is a rigid specification, Software 2.0 is learned from data against an objective, and Software 3.0 is realized by interaction as a computational graph assembled at inference time.

About the name: “Software 2.0” is Andrej Karpathy’s term from 2017 for neural networks as programs. We extended it, and Karpathy later used “Software 3.0” for prompts in English as programs. I don’t mind who owns the label. What I care about is the idea in our definition: an application that isn’t designed or trained in advance, but put together in context when someone asks for it and discarded afterwards. I call this in-context realization.

Here is how I picture an ordinary afternoon with it.

You’re writing a document in a word processor and say: “Show me the latest emails from Anna about the project.” A sidebar opens next to the document with those emails, already searched and filtered. You didn’t open an email client, and nobody had to build an email sidebar for this word processor. The system wrote the search, the filter and the small view on the spot, from your request. You point at one email and say “pull this in”, and the relevant part lands in your document.

Then: “Send this paragraph to my colleague on Discord.” The screen splits, a Discord panel slides up from the bottom, and you confirm the message. “Open the file she posted in that channel yesterday, next to my document, so we can both edit it.” It opens, and you edit it together in real time.

Now the requests get less practical. “Give the whole thing a leopard-print theme.” The interface changes. “Put it on the TV.” The system writes the small piece of code that connects to your TV and mirrors the screen. “Add a music visualizer next to it, I’m putting on headphones, and split the screen so I can play a game while we keep editing.” That works too.

At the end you have something that’s part word processor, part email client, part chat app, part screen mirroring and part game, with a theme nobody would ship. None of it was a product you installed, and you didn’t wait for anyone to build any of these features. Each request was realized from your intent, checked and shown within seconds. When you close it, the parts are thrown away, or cached if you keep asking for the same thing.

The same idea applies to the game mashups this post started with. Nobody would have to decompile Skate to get its board into Modern Warfare: you’d ask for the mechanic, and the game would build the next level, its rules and its story around your decisions while you play. A film could be written the same way for a viewer who wants a story made up on the spot, plot twist included.

The closest picture I know is the scene in Minority Report where someone says “pull that up, compare it with this, project it forward,” and the interface exists only as long as the question does. Today’s tools can do pieces of this, slowly and with mistakes. For the word-processor example to work, the system also needs access to the data behind Anna’s emails and the Discord channel, though not to their apps, and that access is where I expect the companies that hold it to push back.

Source code as a cache

If applications are built on request, the source code behind them starts to behave like a cache.

A cache stores the result of a computation so you don’t have to repeat it. When recomputing is cheap, you keep the cache for speed and throw it away when it’s out of date. Decompilation shows the same thing from the other side: if code can be regenerated from a binary in hours, the code itself was never the scarce part. It stored somebody’s intent plus a lot of work, and the work is what just got cheap. Requests that come back often, like a monthly invoice in the company’s style, will be kept and reused, so a lot of software will still persist. What changes is that you no longer have to buy it from someone who was paid to build it.

A common question about the decompilation wave is whether everything will end up open source. I don’t think so, mainly because open source assumes the code is worth sharing. My guess is that most software will stop being something people ship, own or share. Machines will produce it on demand, for other machines and for one person at a time. The code will still exist, the way intermediate files exist inside a compiler, but few people will read it.

What I use myself

Some of this is already how I work. Over the past year I stopped paying for several pieces of software and had them built instead. Most of what I use every day is still ordinary software (an operating system, a browser, a music streaming service), but where a subscription only existed because building the thing myself was too much work, I’ve started replacing it.

• Myflix is my own streaming app for my own library: about 54,600 lines of TypeScript across seven workspaces, with playback, offline downloads, a scheduled TV channel and an Android TV client. I built it in six days of prompting, partly as a measurement of how much of a familiar product is really the product.
• A music studio built around how I write songs, not around how a subscription service wants me to work. The Graviton Theory records come out of it.
• A news curator that filters the news down to what I want to read, without the ads a general news app is built to sell.
• No office suite. I don’t have an Office licence anymore: agents create and edit Word, Excel and PowerPoint files and PDFs for me when I need them, in whatever format the other side expects.

None of them is a business, and they don’t need to be. Each replaces something I used to pay for because building it yourself was expensive. Together they’re more useful than separately because they share one setup: one login and access gateway, one deployment path, shared storage, my data in one place. It’s a small ecosystem, and ecosystems turn out to be one of the harder things to copy.

AI improving AI

The loop behind the game mashups isn’t specific to games. Decompiling means generating a candidate, checking it, fixing it and repeating. Point the same loop at an AI system’s own prompts, tools and training data, and later at its code, and you get the basic outline of recursive self-improvement. It needs an objective that can be checked and enough iterations.

The idea is old. In 2003 Jürgen Schmidhuber described the Gödel machine, a system that “rewrites any part of its own code as soon as it has found a proof that the rewrite is useful”. Requiring a proof made it impractical. What changed in the last few years is that a test or a benchmark can stand in for the proof:

• STOP (Zelikman et al., 2023) uses a language model to improve a program that improves code, and then runs that improver on itself.
• Self-Rewarding Language Models (Yuan et al., 2024) judge their own outputs during training, and the ability to judge improves along with the ability to answer.
• With colleagues at the University of Pennsylvania and JKU we showed in 2024 that language models can self-improve at web agent tasks: an agent fine-tuned on filtered trajectories it had generated itself raised its WebArena task completion rate by 31% over the base model, without human labels. SymbolicAI, published the same year, is built on self-referential operations, so a program can inspect and rewrite its own computational graph.
• Google DeepMind’s AlphaEvolve (May 2025) pairs Gemini models “with automated evaluators that verify answers”. Among other results, it sped up a kernel in Gemini’s architecture by 23%, which cut Gemini’s training time by 1%: an AI system making the training of AI systems cheaper.
• The Darwin Gödel Machine (Zhang et al., 2025) drops the proof requirement and keeps the changes that score better. Its coding agent rewrote its own tools and raised its SWE-bench score from 20.0% to 50.0%.

All of these work where the check is cheap and automatic, the same condition that made decompilation fast. The hard part is making sure the check rewards what we actually want, because a loop that optimizes a flawed test learns to exploit the flaw. That’s the side I work on now. Cortex treats an agent’s validate-and-repair cycle as a monotone operator and proves that it reaches a fixed point, so the loop can show that it’s finished instead of just claiming it. I described this direction in a brutkasten interview (in German) in January 2025, where I said I expected scientific breakthroughs in five to ten years to be “driven more by algorithms than by human hands alone”.

Science is probably next for the same reason, since maths and much of physics come with ways to check results. A ringdown analysis I did in 2025 with GPT-5 and Codex, cross-checked with neuro-symbolic tools, is a small example of what that workflow looks like.

How fast this could happen

My forecast is that within two to five years, if progress continues roughly as it has over the last three, the technology for in-context realization will be good enough for everyday use. How quickly people switch to it is a separate question, and probably a slower one. The forecast is conditional, and the condition could fail.

It depends on more than models getting smarter. Building an application at the moment someone asks for it needs several things to improve together:

• Speed. Generating the parts of an application in near real time needs much faster output than a chat answer does. Frontier models on GPUs often produce around 100 tokens per second. Specialised hardware and new architectures are already an order of magnitude beyond that: Artificial Analysis measured Cerebras at 2,522 tokens per second on Llama 4 Maverick, and diffusion language models such as Mercury (1,109 tokens per second on an H100) and Gemini Diffusion (1,479) generate many tokens in parallel. Taalas, which hard-wires a model into the chip, reports 17,000 tokens per second per user, for a small and heavily quantized model.
• Model size. Capability is coming from better architectures, not only from more parameters. The Tiny Recursive Model uses 7 million parameters and scores 45% on ARC-AGI-1 and 8% on ARC-AGI-2, “higher than most LLMs (e.g., Deepseek R1, o3-mini, Gemini 2.5 Pro) with less than 0.01% of the parameters”. It’s a specialist for puzzles, not a general assistant, but it builds on the Hierarchical Reasoning Model and points the same way as the broader trend: according to the AI Index 2025, the smallest model scoring above 60% on MMLU went from 540 billion parameters in 2022 to 3.8 billion in 2024.
• Cost of inference. The AI Index reports that the price of GPT-3.5-level performance fell more than 280-fold between November 2022 and October 2024, with hardware costs falling about 30% a year and energy efficiency improving about 40% a year. Epoch AI estimates that the cost of reaching a given level of performance has fallen about 47% per quarter since 2023, roughly 13 times per year.
• Data that can be checked. Neuro-symbolic and synthetic datasets come with their own verifiers. AlphaGeometry was trained on 100 million synthetic theorems and proofs generated by symbolic engines, AlphaProof on millions of auto-formalized problems in Lean, Reasoning Gym ships over 100 task generators with verifiers, and SWE-smith generated 50,000 software tasks, each with tests that tell right from wrong. Simulators do the same for anything visual or physical.
• Verification.

Different groups work on each of these at the same time, and none of them depends on another one finishing first. I don’t see a single clear roadblock, which is why I think this could arrive sooner rather than later. Any of them could stall, though, and the forecast assumes they don’t.

Verification probably matters most for the pace. I call the boundary between tasks that have a cheap automatic check and tasks that don’t the verification frontier. Inside it, each improvement produces better candidates and the check keeps them honest, so progress compounds. Outside it, a person has to judge each step, and things move slowly. The productivity studies I looked at for the moat essay fit this pattern: large speed-ups on well-specified tasks, and slowdowns on work with deep context and no clear test.

The frontier also moves. Self-written tests, formal specifications, simulators and checkable milestones turn judgment calls into steps a machine can verify. Decompilation was always checkable; it was just too expensive to run at scale until recently. I suspect a fair amount of what we call judgment today will turn out to be a check nobody has built yet.

What software is worth now

If software can be built on demand, its price drifts towards the cost of building it plus the cost of checking it. For more and more software, that’s a few cents of compute.

In the moat paper I wrote this as the standard switching-cost condition from economics, with one term pulled out: a customer leaves when replica cost + switching + trust + compliance + integration falls below price + value premium. Generative AI only affects the first term, the cost of building a replacement. The decompilation wave pushes that term towards zero for anything that runs on hardware the customer controls. The other terms are what the second half of this post is about.

I think consumer and business software react quite differently.

For consumer software, replica cost is nearly everything. A consumer is a buyer of one, with no compliance team and no integration work, so cheap rebuilding hits hard. Utilities, productivity apps, media front-ends and single-purpose tools can be reproduced from a description, and now also from the binary. What holds up is what people buy because of who made it. Nobody wants a regenerated GTA; they want the next one from Rockstar. Brands, franchises, communities and shared worlds keep their value, while generic apps lose most of theirs.

Business software erodes more slowly and more unevenly. Companies pay for accountability, compliance, integration and someone to call at 3 a.m., and those don’t go away when rebuilding gets cheap. What’s at risk is per-seat pricing for an interface that an agent can now operate, or replace, for the user.

My estimate, written down so it can be tested later. In my central scenario, by around 2030, roughly a third of what’s sold today as application software (seats, licences and subscriptions) disappears as a separate product or is absorbed into on-demand, agent-driven systems. If you also count the products that survive but stop being sold per seat, it’s about two thirds. These are scenario numbers built on my own assumptions, not results that follow from the statistics; the footnote lists both.¹ What stays is mainly infrastructure, regulated and accountable systems, safety-critical software, and anything tied to hardware or to rights.

Taken together, this is where I think it ends up: software becomes an extension of the thought process, a substrate that’s simply there. You have an intent, and it gets extended into whatever form helps at that moment: a view, an edit, something you can share with someone, a sound, a rendering, a simulation. That’s what the word-processor example shows. The application isn’t the point. The intent is, and software is what it’s made of for as long as it’s needed. What’s worth paying for then is the realization and the things around it that can’t be generated, not owning a copy of the program.

Knowledge work

Software goes first because it’s the most checkable kind of knowledge work: compilers, type checkers and test suites already exist, and the work happens entirely on a computer.

Other knowledge work seems to follow a step behind: finding, reading, comparing, analyzing, summarizing, drafting, booking and filing. Each of these already has a way to check the result or is getting one. Research assistance, document drafting, analysis and procurement are all moving in that direction. Machines will increasingly do this work and write the software they need along the way, mostly for each other.

This doesn’t mean there will be no jobs. People still need to maintain these systems, fix them, extend them and fit them to the organization they serve. What worries me is how many people that takes. My estimate is that organizations doing mostly knowledge work end up at 20 to 30% of today’s headcount, so a company of a thousand people would do the same work with two or three hundred. I can’t put a year on this. It’s the direction I expect, and the number is an intuition along the lines of the 80/20 rule, not a calculation. Most of the people who stay won’t spend their time producing things. They’ll be looking after relationships, setting direction and carrying responsibility.

Music, video and games

Media seems to be going through the same process. Music came first, probably because a song is short and you can tell within half a minute whether it works for you.

Music is already there. In July, Deezer reported that fully AI-generated tracks made up more than half of all new uploads on peak days in June, about 90,000 tracks a day. In a blind test Ipsos ran for Deezer with 9,000 people, 97% couldn’t tell the AI songs from the human one. Suno raised over $400 million at a $5.4 billion valuation in June, about half a year after Warner Music settled its lawsuit with Suno and licensed it instead.

What interests me more than the numbers is how people use it. Suno’s CEO, Mikey Shulman, described it on Sequoia’s podcast in May:

on any given day, 90 percent of the users are going to create something. And the thing that’s hard to wrap your head around is you’re not creating it to go bring it elsewhere

He compared it to cooking at home, and to coding agents: “it’s fun to build things, and it’s fun to use what you build.” That matches what I mean by in-context realization. The song isn’t made for an audience and then distributed. It’s made for the person who asked, often about their own life, so the maker and the listener are the same person. Alvin Toffler had a word for this in The Third Wave (1980): the prosumer, someone who consumes what they produce. He described it as the way most people lived before industrialization and expected it to return. In digital media, it seems to be returning now.

For video and games I’m less sure about the order, and I suspect they’ll arrive at roughly the same time, because I don’t think generating video pixel by pixel is how either will be made. Pure generation has had a mixed year. OpenAI’s Sora app reached a million downloads faster than ChatGPT in October 2025, and OpenAI shut it down in April 2026. Google DeepMind’s Genie 3 turns a text prompt into a world you can walk through in real time, but it stays consistent for “a few minutes”, and the public Project Genie limits sessions to 60 seconds. Keeping a character, a place and a story consistent for an hour is exactly what these models find hardest.

What has worked better for me is the neuro-symbolic version of the same idea. For my Graviton Theory music videos, I built a procedural pipeline in Blender with coding agents, and agents now operate it. A beat tracker measures the song, each album and track gets a written direction (palette, places, which passages to emphasize), and the pipeline turns that into 3D scenes, camera moves and cuts timed to the music. No video-generation model is involved. Because the scene is a 3D model and not a sequence of predicted pixels (an explicit world model, which, as Gary Marcus notes, “every physics engine (and video game)” has and generative models lack), a character looks the same in every shot and the timing stays exact, while the artistic style is still just a setting. The same pipeline renders a photoreal robot factory in Ghost in the Frame and a rain-soaked city painted as anime in The Silent City:

Play video: Graviton Theory: The Silent City (Official Visualizer) ▶ Load from YouTube

A scene, rules and a renderer are also what a game is made of. If agents can build and direct 3D scenes for a film, they can build them for a game, so I’d expect personal films and personal games to arrive together rather than one after the other. It’s also how I’d expect the game from the Software 3.0 section to be built: agents putting together the scene and its rules while you play, where the mashups at the start of this post needed someone to take a finished game apart first. I could be wrong about this: world models are improving quickly, and a generated world that stays consistent for hours would change the picture.

Products aimed at consumers point the same way. Google says people have made over 1.5 billion images and videos in Flow, and its Dreambeans app now generates daily stories for one person, using their own photos if they allow it. Mark Zuckerberg told investors in January that Meta’s apps would move from recommending content to an AI that can “generate great personalized content for you.”

For software and music, I already live partly this way. Some of the software I use every day was built for me by an agent from my description, and a large part of the music I listen to is now my own. I don’t do it because the result is better than what professionals make. I do it because it’s about the things I care about, and because making it is fun. Once these pipelines can carry a character and a plot through an hour, I expect to do the same with series, films and games.

So the point about knowledge work gets broader: most digital things, whether code, text, music, film or games, are moving towards being made on demand by the person who will use them. Professionals keep a role where they add something the consumer can’t: a name, a shared event, a licensing deal, a live performance.

There’s real pushback. Fully AI-generated music gets only 1 to 3% of streams on Deezer, partly because Deezer keeps it out of recommendations, and up to 85% of those streams were fraudulent in 2025. In the same survey, 80% wanted AI music clearly labelled, and Merriam-Webster made slop its word of the year for 2025. I read this as consistent with the argument. People don’t want generated content from strangers pushed at them, while something they generated for themselves can mean a lot to them and little to anyone else.

Simulation

Games lead to one more topic that goes beyond media: simulation, which I think is the next frontier. A scene with rules you can run is a simulation, and simulations do two jobs at once: they’re what films and games are made of, and they’re where AI systems can practise and be checked. Google DeepMind writes that world models “make it possible to train AI agents in an unlimited curriculum of rich simulation environments”, and it tested its SIMA agent inside worlds generated by Genie 3. NVIDIA’s Cosmos platform (January 2025) builds world models for training robots and self-driving cars, which Jensen Huang introduced with “The ChatGPT moment for robotics is coming.” And GameNGen (2024) showed a neural network simulating DOOM at 20 frames per second, where “human raters are only slightly better than random chance” at telling its clips from the real game. Simulators matter in two ways. They’re cheap checks for things that are hard to check otherwise, such as whether generated physics, game rules or camera moves behave as intended. And they produce training data for the models that will write video and game code. Better simulation should speed up exactly the parts of media where I said progress is hardest.

Decompilation got fast because a compiler can check every guess exactly. Simulators give similar cheap checks for physics, robots and cars, though only within their own model, so results in the physical world still have to be validated there. Even so, they move the verification frontier from software towards the physical world.

What keeps its value

If producing things stops being scarce, what’s left? Everything on my list has one thing in common: it isn’t information, so it can’t be generated. Most of the list also maps onto the other terms of the switching condition from earlier: accountability and people are where trust comes from, rights and regulation set compliance, and ecosystems make switching and integration expensive.

Accountability

Being answerable for a decision stays valuable, which is what management originally meant. A machine can produce an analysis, but it can’t be the party that’s liable for it.

We’ll still need lawyers, because a court needs a person who argues and can be disbarred. We’ll still need auditors and consultants, because a third-party opinion is only worth something if the third party puts its name on it and can be blamed. A company’s own model saying “this is fine” means little to a counterparty. The same statement signed by a firm with a reputation to lose means a lot.

Those firms will use AI everywhere and shrink too, but their signature keeps its price.

Rights enforced by law

When copying becomes almost free, what’s left to stop it is the law: copyright, trademarks, patents, licences, data rights and regulatory approval. They become the main protection almost by default, because they can’t be engineered around.

This is the part that worries me most. Legal protection belongs to whoever can afford to enforce it. Large rights holders with legal departments are covered. A two-person studio whose game is decompiled, slightly changed and republished over a weekend has a strong case and no practical way to pursue it.

Ecosystems

A single application is easy to reproduce. A set of applications that share identity, data, payments, devices, developers and users is much harder, because most of the value sits in the connections and in the people already using it. If you copy one piece, you get that piece without the network around it.

That’s why I build my own tools as one system on one setup, and why I expect the software companies that do well to look more like platforms that others build on than like product vendors. It’s also why the word-processor example depends on access that the owners of mail and chat services can grant or refuse.

The physical world

Atoms are harder to regenerate than bits. AI can help design factories, supply chains, energy systems, logistics, robots and labs, but someone still has to build them, and land can’t be made at all. For now this is the most durable item on the list, and it’s one reason I think physical AI is where much of the lasting value of the next decade will be. I mean “for now” seriously: as robotics improves, parts of the physical world become easier to reproduce too, just much more slowly and at much higher capital cost.

People

The oldest one is who you know, who trusts you and who will take your call. When output is cheap, a credible name and people who will vouch for you make up a bigger share of what anyone gets paid for.

Before coding agents, I thought of a product as roughly half and half: one half was having a good idea and building it, the other half was distribution, marketing and networking. Today I’d put it closer to 10 and 90, if not further. That’s a feeling from my own work, not a measurement, but the reasons are concrete. Building has become cheap, so almost everyone can ship something that looks finished. And from the outside, you can’t tell whether solution A or solution B is better by looking at a polished interface, a smart-looking paper, a good pitch deck or a nice animation. All of them are cheap to produce now too.

That makes it harder, not easier, for people who have a good idea or a better solution. Being right isn’t enough to be noticed. Attention goes through people who already have reach: you need to be an influencer or know one to get an idea seen on social media, a strong network to get it funded, or an earlier success to be taken seriously. And the usual way to earn that first success, building a product and selling it, gets harder as software itself loses value.

The moat paper ends on the same idea: an interface is information and can be reproduced, while permission comes from a relationship and can’t be.

What worries me

Everything on that list favours people who already have it. Accountability favours established names, legal protection favours those who can pay lawyers, ecosystems favour companies that already have users, physical assets favour capital, and networks favour the well connected. The capability spreads widely, while the things that capture its value become more concentrated.

The SymbolicAI paper ended with a concern I still have, about the “concentration of data and resources, coupled with a tendency towards closed-source practices” in the industry, and argued for openness as a counterweight. Today I’d add a concrete mechanism. Much of the value of generated output comes from documentation, code, writing, music and data whose authors get nothing for it. In the moat paper I sketch what I call contribution markets: machine-readable rights and provenance, recorded generation events, attribution estimates weighted by confidence, and payment once the confidence is high enough. It’s a proposal and hasn’t been tested, but I’d rather spend the next five years on something like it than on another round of lawsuits.

Where I could be wrong

In order of how seriously I take them:

• The set of checkable tasks could stop growing. If much of knowledge work needs judgment that can’t be turned into a check, software only partly collapses, and the effect on jobs is much smaller than the 70 to 80% headcount reduction I estimate above. This is the biggest risk to the forecast and the reason I state it conditionally.
• Shared tools and shared culture could matter more than I expect. People work together through common tools, formats and conventions; a spreadsheet is useful partly because everyone’s spreadsheet behaves the same way. Personal on-demand software may end up next to shared software that stays standard, much like protocols outlived the products built on them. Media has the same issue in a stronger form: we watch what others watch so we can talk about it, and a show made for one person has nobody to talk about it with.
• Security and law could catch up. Hardware attestation, running code on servers instead of customer machines, and new laws on decompilation could bring back much of the effort. That would slow down the copying of consumer software, but it wouldn’t affect in-context realization, which doesn’t need anyone else’s binary.
• Cost and energy could slow things down. Generating software for every request costs more than running a compiled program. Caching helps, but caching brings back part of the shipped artifact.

The strongest version of the opposite view I’ve read is Benedict Evans’s AI, tools and transformation. He argues that making tools easier to build doesn’t solve the hard part: “The hard part is knowing that you need a tool for this in the first place, and then knowing what the tool should do.” I think he’s right about companies, and it’s one reason I expect business software to change more slowly than consumer software. For personal use I’m less convinced. When I built my streaming app and my music studio, I knew exactly what I wanted, and I suspect that’s true for a lot of everyday software. How much of the market falls on each side is something I’m still thinking about.

A dated record

Most of this was public before this week. Here are the dates, in case you want to check:

Date	What	Where
30 Nov 2022	SymbolicAI framework repository created	SymbolicAI on GitHub
Feb 2024	Software 3.0 defined as in-context realization; self-referential, self-evolving architectures	arXiv 2402.00854, CoLLAs 2024
May 2024	LLM agents self-improving on their own trajectories, +31% on WebArena	arXiv 2405.20309
Oct 2024	Doctoral thesis, same Software 3.0 definition	JKU thesis
28 Jan 2025	The “self-optimization path”: algorithms that improve algorithms	brutkasten interview, 22:39
30 Sep 2025	End-to-end AI-assisted physics workflow	Ringdown bounds paper
May 2026	Myflix: a streaming app in six days of prompting	Project
5 Aug 2026	Implementation moats, the switching condition, contribution markets	Paper · Essay
4 to 5 Oct 2026	Two music videos from an agent-operated, procedural Blender pipeline, in anime and photoreal styles	The Silent City · Ghost in the Frame
6 Oct 2026	This essay	This page

Where this leaves me

I’m much less sure about the timing than about the direction. I think software, in the form we know it, was temporary. It was a way of writing intent down while turning intent into working behaviour was expensive. As that gets cheaper, the written form matters less, and machines will write most of it for each other. Other knowledge work and media seem to be on the same path, a little behind. The game mashups this post started with are an early sign of it: what took a studio years to write down can now be taken apart and written again in a weekend.

What’s left for people is what can’t be generated: being accountable for an outcome, holding rights, being part of something bigger than one app, owning physical things, and being someone others trust. The music video above is a small example. AI systems did most of the production work, and what they couldn’t supply was what the song is about, the decisions along the way and my name on it.

If you disagree with any of this, especially the numbers, please write to me. I’d much rather find out now where I’m wrong.

What others are saying

Plenty of people have made parts of this argument before me, and many serious people disagree with parts of it. I collected the voices I found most useful, grouped by background, with dates and links. Quotes are verbatim, […] marks a cut, and quotes from videos have a timestamp.

Roughly where they land:

• On verifiability there’s close to a consensus, from Rich Sutton in 2001 to Jason Wei in 2025 to programmers on YouTube this autumn: the cheaper the check, the faster AI gets good at a task.
• On the direction for software there’s broad agreement. Nadella, Thompson, Bain and Gartner all describe applications and per-seat pricing giving way to agents.
• On size and speed, my numbers are higher than most. Gartner puts about $234 billion, roughly 20% of enterprise application SaaS spending, at risk by 2030. My central scenario of about a third is measured on a different base (all application spend today, consumer apps included), which comes to roughly $300 billion, and about two thirds if repricing away from seats counts. McKinsey’s midpoint for automating half of today’s work activities is 2045. Acemoglu expects modest productivity gains, and the Yale Budget Lab, Stanford and Anthropic’s own economists see no broad effect on the labour market yet. The one consistent signal is fewer young workers in the most exposed jobs.
• On jobs, a strong group argues against my headcount estimate: cheaper software means more demand for it and more people building it (Autor, Ng, Andreessen, and Gartner’s own engineering forecast).
• On media, the supply is clearly there and the demand is debated. Generated music already makes up half of new uploads on one major service, platforms are building feeds that generate content for each user, and audiences push back against generated content that isn’t made for anyone in particular.

Researchers and builders

• Rich Sutton, reinforcement-learning pioneer and 2024 Turing Award laureate, Verification, The Key to AI (15 Nov 2001): “The Verification Principle: An AI system can create and maintain knowledge only to the extent that it can verify that knowledge itself.” The oldest version of the verifiability argument I know of.
• Jason Wei, AI researcher known for chain-of-thought prompting, Asymmetry of verification and verifier’s rule (15 Jul 2025): “The ease of training AI to solve a task is proportional to how verifiable the task is. All tasks that are possible to solve and easy to verify will be solved by AI.”
• Tan, Luo, Li and Zhang, LLM4Decompile (first posted 8 Mar 2024; quoted from v3, 22 Oct 2024): their models “significantly outperform GPT-4o and Ghidra on the HumanEval and ExeBench benchmarks by over 100% in terms of re-executability rate.” Re-executability is checked by compiling and running tests, and the paper came out two years before this month’s decompilation wave.
• Andrej Karpathy, co-founder of OpenAI, coined “vibe coding” on X (2 Feb 2025): “you fully give in to the vibes, embrace exponentials, and forget that the code even exists.” That’s close to what I mean by source code becoming a cache. In Software Is Changing (Again) (17 Jun 2025, 3:05) he described his version of Software 3.0: “your prompts are now programs that program the LLM.”
• Karpathy again, same talk at 27:34, against short timelines: “When I see things like oh 2025 is the year of agents I get very concerned and I kind of feel like you know this is the decade of agents and this is going to be quite some time. We need humans in the loop. We need to do this carefully. This is software. Let’s be serious here.”
• Satya Nadella, CEO of Microsoft, on business applications in the agent era, BG2 podcast (12 Dec 2024, 46:53): “They are essentially CRUD databases with a bunch of business logic. The business logic is all going to these agents.” He describes the logic moving into an AI layer, which fits my point about per-seat pricing better than the idea that software disappears.
• Dario Amodei, CEO of Anthropic, at the Council on Foreign Relations (10 Mar 2025), predicted that within “three to six months” AI would be “writing 90 percent of the code”, and added: “But the programmer still needs to specify […] the conditions of what you’re doing.” His caveat about specification is the part I find most relevant here.
• David Heinemeier Hansson, creator of Ruby on Rails, Rails World 2026 keynote (24 Sep 2026, 40:43): “Writing code by hand is no longer an economically productive enterprise for the vast majority of programmers working at the vast majority of companies. That’s today.” Later in the talk, citing ATMs and bank tellers against the job-loss story: “No one knows anything about the future.”
• Andrew Ng, founder of DeepLearning.AI, on X (13 Mar 2025): “Some people today are discouraging others from learning programming on the grounds AI will automate it. This advice will be seen as some of the worst career advice ever given. […] As coding becomes easier, more people should code, not fewer!” This disagrees directly with my headcount estimate.
• Simon Willison, co-creator of Django, Not all AI-assisted programming is vibe coding (19 Mar 2025): “I won’t commit any code to my repository if I couldn’t explain exactly what it does to somebody else.” A practical version of the accountability point.
• Gary Marcus, cognitive scientist and AI critic, Is vibe coding dying? (22 Oct 2025): “Vibe coding can be fine if you are building something very familiar, but is less reliable for the unfamiliar.” I’d read this through the verification frontier, since familiar tasks are usually the ones with known checks. In Generative AI’s crippling and widespread failure to induce robust models of the world (28 Jun 2025) he makes the point behind my section on video: “Video-generators (even the latest ones) too are insufficiently anchored in the world.”

Analysts and markets

• Gartner, $234 Billion in Enterprise Application Software Spend Is at Risk from Agentic AI (1 Jul 2026): up to $234 billion “exposed to agentic arbitrage between now and 2030”, roughly 20% of enterprise application SaaS spending. George Brocklehurst: “Agentic systems deliver outcomes directly, bypassing traditional user experience (UX)-heavy applications and making the software invisible.” On scale, he sees it differently from me: “This is less an apocalypse and more of a metamorphosis. SaaS will not be destroyed; it will emerge in a different form.”
• Gartner, agentic AI forecast (25 Jun 2025): “Over 40% of agentic AI projects will be canceled by the end of 2027, due to escalating costs, unclear business value or inadequate risk controls.” The same release forecasts that 33% of enterprise software applications will include agentic AI by 2028, up from less than 1% in 2024, and that at least 15% of day-to-day work decisions will be made autonomously.
• Gartner, engineering workforce forecast (3 Oct 2024): 80% of the engineering workforce must upskill through 2027, from a report titled AI Will Not Replace Software Engineers (and May, in Fact, Require More). Philip Walsh: “human expertise and creativity will always be essential to delivering complex, innovative software.”
• Bain & Company, Will Agentic AI Disrupt SaaS? (23 Sep 2025): “In three years, any routine, rules-based digital task could move from ‘human plus app’ to ‘AI agent plus application programming interface (API).’” Their summary: “Disruption is mandatory, but obsolescence is optional.”
• McKinsey Global Institute, The economic potential of generative AI (14 Jun 2023): $2.6 to $4.4 trillion a year across 63 use cases. Current technology could automate activities that take up “60 to 70 percent of employees’ time today”, with half of today’s work activities automated “between 2030 and 2060, with a midpoint in 2045”. That’s a much slower timeline than mine.
• World Economic Forum, Future of Jobs Report 2025 (8 Jan 2025): 170 million roles created and 92 million displaced by 2030, a net gain of 78 million, while 41% of employers “plan to reduce their workforce as AI automates certain tasks.”
• Goldman Sachs Research, Generative AI could raise global GDP by 7% (5 Apr 2023): the equivalent of 300 million full-time jobs exposed to automation, but “most jobs and industries are only partially exposed to automation and are thus more likely to be complemented rather than substituted by AI.”
• Reuters, on the market reaction (24 Feb 2026): “Anthropic’s release of a legal plug-in ignited an $830 billion global selloff in software and services stocks […] over six trading days as investors worried that AI-powered automation could undercut [the] revenue streams of these companies.” Markets reacted to the replacement-cost argument before most companies did.
• Sebastian Siemiatkowski, CEO of Klarna, on X (3 Mar 2025): “we did shut down Salesforce a year ago, as we have many SaaS providers”, about “1,200 SaaS” in total by an internal estimate. And: “No, I don’t think it is the end of Salesforce; might be the opposite.” Klarna did with its vendors roughly what I did with my subscriptions, and he still expects vendors to consolidate rather than disappear.

Economists

• Carl Shapiro and Hal Varian, Information Rules (Harvard Business School Press, 1999): “Information is costly to produce but cheap to reproduce.” And on rights: “the legal grant of exclusive rights to intellectual property via patents, copyright, and trademarks does not confer complete power to control information. There is still the issue of enforcement.” My section on rights makes the same point, twenty-seven years later.
• Eloundou, Manning, Mishkin and Rock, GPTs are GPTs (OpenAI and Wharton, Mar 2023; Science, 2024): “around 80% of the U.S. workforce could have at least 10% of their work tasks affected by the introduction of LLMs, while approximately 19% of workers may see at least 50% of their tasks impacted.” The authors explicitly make no prediction about timing.
• Erik Brynjolfsson, Bharat Chandar and Ruyu Chen, Stanford Digital Economy Lab, Canaries in the Coal Mine?, August 2026 update (12 Aug 2026): employment for 22-to-25-year-olds in highly AI-exposed occupations “now stands about 19% below where it would be” otherwise, but “We do not see widespread, economy-wide job displacement associated with AI.” Their split lines up with the verification frontier: declines “in occupations that rely heavily on codified knowledge”, increases among experienced workers “in occupations that rely more heavily on tacit knowledge.”
• Maxim Massenkoff and Peter McCrory, Anthropic, Labor market impacts of AI (5 Mar 2026): “Computer Programmers are at the top, with 75% coverage”, yet “We find no systematic increase in unemployment for highly exposed workers since late 2022, though we find suggestive evidence that hiring of younger workers has slowed in exposed occupations.”
• Daron Acemoglu, MIT, 2024 Nobel laureate in economics, The Simple Macroeconomics of AI (NBER, May 2024), calls the effects “nontrivial but modest”, at “no more than a 0.66% increase in total factor productivity (TFP) over 10 years.” This is the strongest disagreement with my timeline.
• The Budget Lab at Yale, Tracking the Impact of AI on the Labor Market (15 Sep 2026 update): the analysis “does not provide clear evidence of labor market disruption associated with AI.”
• David Autor, MIT, AI Could Actually Help Rebuild The Middle Class (Noema, 12 Feb 2024): “Demand for healthcare, education and computer code appears almost limitless”. And: “But in other domains, yes, rapid productivity growth will erode employment.” A careful argument that cheaper software leads to more demand, which cuts against my estimate of how much software spending disappears.
• Anton Korinek and Donghyun Suh, Scenarios for the Transition to AGI (NBER, Mar 2024): “If automation proceeds sufficiently slowly, then there is always enough work for humans, and wages may rise forever. By contrast, if the complexity of tasks that humans can perform is bounded and full automation is reached, then wages collapse.” My forecast is conditional for the same reason theirs is.
• Kristalina Georgieva, IMF, AI Will Transform the Global Economy (14 Jan 2024): “almost 40 percent of global employment is exposed to AI”, and in advanced economies “about 60 percent of jobs may be impacted by AI.”

Media and creators

• Alvin Toffler, The Third Wave (1980): “During the First Wave most people consumed what they themselves produced. They were neither producers nor consumers in the usual sense. They were instead what might be called ‘prosumers.’”
• Wang, Lin, Feng, He and Chua, Generative Recommendation: Towards Next-generation Recommender Paradigm (7 Apr 2023): “Recommender systems typically retrieve items from an item corpus for personalized recommendations.” The paper proposes “generating personalized content through generative AI” instead, a similar idea to mine from a different starting point.
• Mikey Shulman, CEO of Suno, Sequoia Training Data podcast (13 May 2026): “Before Suno, basically everybody was a consumer of music.” And: “it’s fun to build things, and it’s fun to use what you build.” He predicts “way more of these creative entertainment things” within 10 to 20 years.
• Deezer, AI music has surpassed 50% of new music uploads (21 Jul 2026): “90,000 AI-generated tracks per day now represent over 50% of all new music uploads on Deezer at peak level in June, 2026.” The same release: fully AI-generated music “accounts for only a small fraction of streams on Deezer, between 1-3%”, and in its Ipsos survey 97% “couldn’t tell the difference” in a blind test.
• Warner Music Group and Suno, partnership announcement (25 Nov 2025): “The deal also settles previous litigation between the companies.” The release speaks of “100 million creators” on Suno. The lawsuit ended in a licence, which fits the section on rights.
• Mark Zuckerberg, CEO of Meta, Q4 2025 earnings call (28 Jan 2026): “Today our apps feel like algorithms that recommend content. Soon, you’ll open our apps and you’ll have an AI that understands you, and also happens to be able to show you great content or even generate great personalized content for you.”
• Google Labs, Dreambeans (10 Sep 2026): “an experiment that creates personalized daily collections of stories”, which can “incorporate visuals of you and your loved ones” from Google Photos. A real product that makes media for one person.
• Sam Altman, CEO of OpenAI, Sora 2 (30 Sep 2025): “Creativity could be about to go through a Cambrian explosion”, with a warning in the same post: “It is easy to imagine the degenerate case of AI video generation that ends up with us all being sucked into an RL-optimized slop feed.” OpenAI discontinued the Sora app on 26 Apr 2026.
• Google DeepMind, Genie 3 (5 Aug 2025): “Given a text prompt, Genie 3 can generate dynamic worlds that you can navigate in real time at 24 frames per second, retaining consistency for a few minutes at a resolution of 720p.”
• Ted Sarandos, co-CEO of Netflix, Q2 2025 earnings call (17 Jul 2025), on the first generative-AI final footage in a Netflix original: the sequence “was completed 10x faster” than with traditional VFX tools. He calls it “real people doing real work with better tools.”
• Kapwing, AI Slop Report (28 Nov 2025): on a fresh YouTube account, “104 (21%) of the first 500 videos were AI-generated”. Since July 2025 YouTube’s monetization policy calls mass-produced content “inauthentic content”.
• Merriam-Webster, 2025 Word of the Year (15 Dec 2025): slop, “digital content of low quality that is produced usually in quantity by means of artificial intelligence.”
• Horton, White and Iyengar, Columbia Business School, Bias against AI art can enhance perceptions of human creativity (Scientific Reports, 3 Nov 2023): “people devalue art labeled as AI-made across a variety of dimensions, even when they report it is indistinguishable from human-made art”. Good evidence that who made something still matters to people.
• SAG-AFTRA, on the synthetic “actress” Tilly Norwood, via Variety (30 Sep 2025): “It has no life experience to draw from, no emotion and, from what we’ve seen, audiences aren’t interested in watching computer-generated content untethered from the human experience.”

Commentators

• Ben Thompson, Stratechery, Apps, Agents, and Aggregation (28 Sep 2026): “I had custom UI generated just for me, with no need that the app be shared with anyone else. It’s effectively disposable, because it’s infinite.” The closest description of in-context realization by someone else that I’ve found.
• Benedict Evans, AI, tools and transformation (3 Sep 2026): “None of this is solved by making easier to write code - by making it easier to make tools. The hard part is knowing that you need a tool for this in the first place, and then knowing what the tool should do.” Once a workflow matters, he argues, the company has to institutionalize it: “You need audit, security, maintenance and accountability.” The best argument I’ve found against my point on consumer software, and it ends up close to my point on accountability.
• Theo Browne, t3.gg, Stop Pretending You Understand Your Codebase (7 Sep 2026, 19:16): “compilers are easier here because you have verifiable inputs and outputs. So you can make some pretty brutal end-to-end tests that will guarantee in most cases things are handled.”
• ThePrimeagen, a long-time sceptic of AI coding, on the Bun runtime’s rewrite from Zig to Rust, The Great Bun Rewrite (15 Jul 2026, 11:18): “I know that I rag a lot on AI, but I do think that this is one of its strong suits, which is translating one thing to the next thing.” Six days later, in You won’t fall behind (10:26), he pushed back on the urgency: “Don’t you realize that there’s a little bit of a perverse incentive when the people who are selling shovels telling you the only thing you ever need to practice or do is dig holes?”
• Fireship, DHH has gone completely off the rails… (28 Sep 2026, 3:45): “I think we’ll see all frameworks, languages, and runtimes converge down to a single point, like one universal language that can build any type of software you can imagine. A language optimized for tokens that no human needs to understand.”
• George Hotz, founder of comma.ai, I love LLMs, I hate hype (12 Jul 2026), on the jump from “fancy autocomplete” to takeover scenarios: “I’ll bet you everything I have that this doesn’t happen.” And against the productivity story: “where’s all this new magical software that the productivity improvements should imply?”
• Steve Yegge, The Death of the Junior Developer (24 Jun 2024): “It’s a bad year to be a junior anything.” The Stanford numbers above measure that claim two years later.
• Marc Andreessen, Why Software Is Eating the World (20 Aug 2011), which warned that “many workers in existing industries will be stranded on the wrong side of software-based disruption”, and Why AI Will Save the World (6 Jun 2023), which calls the core mistake of “the automation-kills-jobs doomers” the “Lump Of Labor Fallacy”: “the incorrect notion that there is a fixed amount of labor to be done in the economy at any given time.”
• Modern Vintage Gamer, Recomps and Decomps have taken over Retro Gaming… (28 Sep 2026, 8:20), from inside the scene this post started with: “there is a lot of AI that’s being introduced in the re-comp scene at the moment, and it seems like there’s just a flurry of re-comp’s coming out all the time, and there’s really a lot less kind of care and attention that’s being put into them.” A compiler can check that the bytes match, but not how much care went into the result.
• News coverage of the wave itself: The Verge on the browser port of Halo: Combat Evolved (5 Oct 2026), “The video game decompilation movement has done it again”, and Windows Central (1 Oct 2026): “these projects are largely driven by AI-powered tools”.

Footnotes

1. This is an illustrative scenario, not a calculation from statistics. The published figures set the scale; the percentages in between are my assumptions. Base: application software is about $0.9 trillion a year. Gartner forecasts $1.47 trillion of enterprise software spending in 2026; I assume 50 to 60% of that is applications, because Gartner doesn’t publish the split. I add roughly $90 billion of non-game consumer app spending (Sensor Tower reports $167 billion of app-store spending in 2025, about half of it games). Three effects, each with my assumption: (1) Agents doing the work directly. Gartner puts about 20% of enterprise application SaaS spending at risk by 2030, and Bain estimates that 20 to 60% of workflow tasks per business function can be automated. Automating a task doesn’t always remove what’s paid for the software, so I assume separately that 15 to 25% of spend is absorbed by 2030. (2) Unused seats cut once agents make companies look at them. Zylo finds 36% of SaaS licences unused; I assume about 60% of application spend is priced per seat and that 25 to 55% of the unused seats get cancelled, which gives about 5 to 12%. (3) Tools rebuilt in-house. Retool finds 35% of teams have replaced at least one SaaS tool with their own, while Menlo Ventures finds 76% of AI solutions are still bought rather than built; I assume 2 to 8%. The three overlap (a seat removed because an agent does the work may also be an unused seat), so simply adding them, to roughly 22 to 45%, overstates the total. “Roughly a third” is my judgment within that range, not a computed value. Broader figure: IDC predicts that “by 2028, pure seat-based pricing will be obsolete”. If I assume half of the remaining spend moves to usage or outcome pricing, the total reaches about two thirds; that assumption carries most of the number. On the labour side, MIT’s Iceberg Index finds that current AI can technically do skills worth 11.7% of US wages, which measures exposure, not adoption. ↩