The AI Decompilation Explosion: When Software Gets Completely "Solved"

AI's coding capabilities are advancing at a breathtaking pace — and the disruption this unleashes is something most people are only beginning to grasp. People are transplanting characters from one game into another's world: Super Mario in Elden Ring, skateboarding mechanics dropped into Call of Duty, Spider-Man inserted into a Batman game. Others have used AI to clone Photoshop outright and release it as a free, open-source project. Behind these seemingly wild experiments lies a single unifying technical logic — AI is extraordinarily good at converging on a target within a "verifiable loop."

Decompilation Explained: Reconstructing Human Code from Machine Code

To understand this wave, you need to understand what decompilation actually is. The source code a programmer writes is a human-readable, editable version of a program. A compiler translates it into machine code that runs efficiently on hardware. The Grand Theft Auto game files you download are machine code — technically readable, but figuring out what each line does through manual inspection, then verifying your guesses, could take years.

Decompilation reverses that process: you know the output (Mario jumps), but you don't know the input code that produces it. So you enter a guess-and-verify loop — write some code, see if Mario actually jumps, and if not, start over.

One important nuance: decompiled code is not a line-for-line replica of the original. Comments are typically stripped during compilation, variable names disappear, and the compiler restructures and simplifies code along the way. A simple example: a method that returns "2+3" can be compiled down to just returning "5." So when decompiling, you only need to write return 5. This doesn't affect the outcome, though — the game's behavior, appearance, and feel remain identical.

Decompilation has a long history in gaming, but traditional approaches depended almost entirely on manual reverse engineering. Reverse engineers needed fluency in assembly language and specialized disassembly tools like IDA Pro and Ghidra to translate machine code into low-level assembly instructions, then infer high-level logic from those. This required deep knowledge of target platform architectures (x86, MIPS, PowerPC, etc.) as well as extensive domain experience to recognize patterns generated by common compilers. Well-known open-source game reconstruction projects — like the Super Mario 64 decompilation (sm64decomp) — mobilized dozens of volunteers over several years to painstakingly reconstruct compilable C source code. That extreme human cost kept decompilation confined to specialized communities and a small number of enthusiasts. AI is now dramatically lowering that barrier.

Why AI Compresses Years of Work Into Days

Decompilation is almost tailor-made for AI: it's code-dense, and it comes with a built-in verifiable loop. AI guesses what a piece of logic might be, checks it against the original, and keeps going. AI doesn't get tired, hungry, or sleepy — it just keeps churning until it has an exact clone of the game.

Three factors explain the speed leap: the game can be broken into small chunks and distributed across many parallel agents; AI writes code faster than humans; and AI can work continuously toward a verifiable goal until it's achieved. Combine all three, and what once took a team several years now takes a few days.

A concrete example: Chris Lewis spent nearly two years decompiling Snowboard Kids — then completed it in 84 days with AI assistance, and that timeline is shrinking fast. The author himself rebuilt Super Mario World from scratch using GPT-6.1 on a mod retro device (similar to a remastered Game Boy) gifted at the OpenAI Developer Day, with the process running continuously for over four days and expected to finish within a few more. He noted that with models now cheaper and more efficient, he's actually struggling to use up his token budget.

Note: Specific model names mentioned in the video (such as GPT-6.1, GPT-6 Pro, Fable 5.1) are the creator's own characterizations — readers should verify their accuracy independently.

Four Technical Approaches to Game Mashups

Blending two games together has four technical layers, ranging from shallow to deep.

Skin Swap is the simplest — you only change what appears on screen. Swap Batman's visuals for Spider-Man's and the character looks different, but all the underlying behavior still belongs to the original game.

Pass-through Mod runs two games simultaneously and builds a bridge between them. Take Minecraft inside GTA: the Minecraft engine handles its own blocks and mobs, while the mod aligns cameras, merges their visuals, and relays messages between them. When TNT explodes in Minecraft, the connection layer tells GTA to spawn an explosion at the corresponding location. Walls need to line up, physics need to match, and both games must agree on what's happening.

Mechanic Transplant moves the behavior of one game into another — adding Mirror's Edge-style parkour to Skyrim, or injecting skateboarding into a shooter. You're porting over acceleration, jump height, landing and collision rules, and making them work in a new engine. Sometimes you can move the original code directly and it just works; other times, AI can't access the code at all and must observe the mechanic, then rebuild it from scratch in the new game. The latter approach was nearly impossible before AI.

Full Reconstruction is the most intensive and AI-dependent approach: you're essentially writing replacement software, studying the original, understanding how it works, and implementing the parts you need. It gives you the most control and enables the most faithful mashups — but it's also the most time-consuming.

The proprietary nature of game engines is the key context for understanding why these four approaches differ so dramatically in difficulty. Modern commercial games typically use closed-source engines (like GTA's RAGE engine or Skyrim's Creation Engine) that don't expose their source code. Modders can only modify behavior through the scripting interfaces the game provides or through memory injection. Skin swaps are easiest because graphical assets (textures, models) are stored on disk in relatively standardized formats — no need to understand engine internals. Pass-through mods and mechanic transplants, by contrast, require real-time communication between two completely different memory models and physics systems, with technical complexity rising exponentially. AI's value is especially pronounced in mechanic transplants — it can "sense" target behavior by repeatedly testing parameters (parkour acceleration curves, collision detection thresholds), then iteratively reproduce them in the new engine. This is fundamentally black-box fitting of a physics system without any documentation.

"Software Is Solved": From Photoshop to Mathematics

The author raises an even bigger thesis: if AI can reconstruct a game without ever seeing its source code, why can't it do the same for all software?

Someone pointed AI at a locally installed copy of Photoshop, had it learn through use while rebuilding it from scratch, and ultimately open-sourced the result as a free alternative called PhotoCraft. The author himself once used AI to reconstruct Excel by observing behavior — the AI clicked cells, watched what happened (like adding a formula), and reproduced that behavior, all without ever seeing the source code.

By the same logic, Adobe Premiere — or any software — could be rebuilt. The author's conclusion: "Software is solved." But this doesn't mean building companies around software is pointless. If your only moat is the software itself, then yes, you're exposed. What actually matters is everything around the software: training, enterprise features, customer support, ongoing maintenance and updates.

All of this circles back to the core concept of the loop. It's why Claude Code, Codex, and Cursor have all introduced /goal or /loop mechanics — set a high-level objective and let AI keep working until it's done. Mathematics works the same way. You roughly know what you're trying to prove but don't know the path, so you let AI tirelessly try every possible route. According to an analysis by Twitter user Will Depew cited by the author, after having AI categorize nearly three years of mathematical discoveries using GPT-6 Pro and Fable 5.1, the results showed a large and growing share of new proofs coming from AI.

Anything Verifiable Is Solvable — But Human Taste Is Becoming Rarer

The author's core conclusion: any task with a verifiable outcome — even if you don't know how to do it, as long as you can judge whether the answer is right — can essentially be solved by AI. This extends to recursive self-improvement: point AI at optimizing its own efficiency, speed, and methods; every time it finds a better approach, apply it back to itself; watch an intelligence explosion unfold. He cites Google's AlphaEvolve as an example — the project reportedly saves Google billions of dollars annually by using AI to optimize low-level code. This is also why frontier labs are discussing "slowing down at the frontier" and emphasizing alignment.

But in a world where anyone can effortlessly generate digital content, the author argues that "creativity" and "judging what resonates with people" become more important than ever. You can generate a million beautiful images — that doesn't mean any of those million will move someone emotionally. Whether art is meaningful can only be determined by putting it out there and watching the response. That, precisely, is the unverifiable part.

As for the concern that others will copy your ideas — the author sees this as a constant throughout art history. Music has always been remixed and resampled; most works are derivatives of what came before. AI simply causes the volume of derivatives to explode. And when there's more noise than ever, the work that truly carries signal becomes all the more precious. You can put Mario in Elden Ring — but the next Mario, the next Elden Ring, will still require a human to tell a compelling story and design a game worth playing.

Recursive self-improvement is one of the central long-term topics in AI safety research. The basic logic: if an AI system is powerful enough to modify and optimize its own code or weights, each improved version will be better at "improving itself" than the previous one, forming a positive feedback loop that could theoretically reach intelligence far beyond human level in a short time — a threshold often called the "intelligence explosion," first systematically described by mathematician I.J. Good in 1965. Google's AlphaEvolve project is a practical implementation of this direction: using evolutionary algorithms to drive AI in automatically optimizing low-level computational kernel code, it has already achieved efficiency gains in core operations like matrix multiplication that surpass decades of accumulated human expert work. This marks a shift in what AI is optimizing — from specific tasks to computational infrastructure itself — with potential implications far beyond rebuilding or cloning any single piece of software.