Work & economics October 14, 2026

Code is free, context is not: if an AI clones your app over a weekend, what are you actually selling?

AI
Reverse-Engineering
Open-Source
Rust
Security
SaaS
Technical-Debt
Career

Between 30 September and 1 October 2026, a GitHub account called storytold published seven Rust repositories. They are clones of seven Adobe applications: Photoshop, Illustrator, Premiere Pro, Lightroom, Acrobat Pro, After Effects, InDesign. MIT or Apache-2.0 licensed, with installers for macOS, Windows and Linux and a WebAssembly build. Written, by the author’s own account, with Claude Opus 5.5.

Two months ago, on this blog, I wrote that intelligence had become a commodity and value was shifting to the hardware. That was the raw material. This is the manufactured good: source code, the asset that justified software company valuations for thirty years.

The question going round for two weeks is the right one: if an AI clones your application over a weekend, what are you really selling? Answering it, though, means first separating two things this month’s coverage has blended together: what actually collapsed and what merely looks collapsed because nobody read the numbers.

What really happened with ArtCraft

The project is called ArtCraft, and the figures below are the project’s own claims, taken from its documentation. Nobody has verified them independently, and they should be read with that reservation — but they are interesting precisely because they come from the party with every incentive to look further along than it is.

Metric (PhotoCraft, as of 5 October 2026)	Claimed value
Photoshop menu items wired to real commands	625 of 625 (100%)
PSD file round-trip	169 of 169 in the mixed corpus
Pixel-for-pixel match on PSD files	115 of 170, about 68%
Functional parity on mainstream workflows	about 86%
Parity including Adobe’s generative features	about 75%
Fitness for daily professional use	about 25-35%
Generative features implemented	about 5%, deferred by choice

That last row is the one that counts, and it is why the repository’s own banner states plainly that it is not yet a replacement for Photoshop in daily professional work.

This does not diminish the achievement, which is enormous. But it says exactly what collapsed. Not professional software: the cost of the first 80%. Wiring 625 menu items, implementing the public PSD specification, writing a raster engine from scratch in Rust — work that once took a team and two years, and now takes one engineer with good architectural judgement plus an agent that grinds.

What AI made almost free is not the finished product. It is the credible prototype. And in a subscription market, a credible prototype is already a problem for whoever collects the subscription.

The fortress was made of friction, not secrets

To see why this happened now, look at decompilation — the point where protecting code has always been a practical matter more than a legal one.

Translating machine code into something readable has always been possible: Ghidra (released by the US National Security Agency), IDA Pro and Binary Ninja have done it for years. The trouble is that they produce pseudo-C that is correct at instruction level and unreadable to a human: compilation throws away variable names, logical structures, comments and types to optimise execution. What remains is a puzzle stripped of semantics. The barrier was never secrecy: it was cognitive friction, and it cost person-years.

AI agents do not replace disassemblers; they sit on top as an interpretive layer, inferring the lost context. The bridge is the Model Context Protocol, the standard that lets a model drive external tools — I covered it in its own lesson. MCP servers for Ghidra already exist (the best known is LaurieWired’s GhidraMCP: a Java plugin plus a Python server, with forks exposing anywhere from a few dozen to over two hundred tools), as do servers covering both Ghidra and IDA Pro headlessly. From there the agent inspects functions, renames variables by inference, reconstructs the underlying formulas and tests its hypotheses by recompiling and diffing against the binary.

The practical effect lands on an old, settled legal practice: clean-room design. Studying the behaviour of a proprietary system and then writing a new, independent version of it is lawful — the classic precedent is Sony Computer Entertainment v. Connectix (1999-2000), where reverse engineering the PlayStation BIOS to build an emulator was held to be fair use. That methodology demanded large teams and long timelines. That is where AI made the difference: it did not change the law, it compressed the cost of staying inside it.

The hard boundary: mechanics clone, expertise does not

This is where things stop, and they stop predictably. An agent replicates the interface, the standard computational logic, the handling of documented formats. It does not replicate what is written down nowhere:

proprietary colour science, meaning decades of correction profiles layered per individual camera and lens;
third-party ecosystems, from VST3 audio plugins to OpenFX for video, which are worth as much as the application hosting them;
the hundreds of edge-case behaviours professional users have in their fingers and nobody ever documented.

This is not a detail: it is exactly the gap between 86% of mainstream workflows and 25-35% fitness for daily use. The part that is easy to clone is the part that had already stopped costing anything. The expensive part is accumulated domain knowledge, and that cannot be inferred from a binary: it has to be gathered in the world.

Consoles: where the story inflates

There is a companion story doing the rounds, and it deserves more precision than I keep finding, because it is the case where enthusiasm outran the facts.

On the PlayStation 5 front the real projects are KytyPS5 and SharpEmu: the first made its source public on 16 July 2026, with an initial commit of roughly 206,000 lines across 427 files. Both, however, are at the first-boot stage: boot screens, menus, a few light titles. KytyPS5 runs Astro’s Playroom — the demo bundled with the console, not Astro Bot — and gets in-game on some independent titles. As of today there is no complete, playable PS5 game.

Two corrections I see needed regularly:

shadPS4 is a PS4 emulator, not a PS5 one. It gets cited among the PlayStation 5 projects because it is the best known, but it is solving a different and far more mature problem.
There is no public evidence that AI broke through the PS5’s protections. The only documented link between emulation and AI in this cycle is that shadPS4 adopted a disclosure policy for AI-assisted contributions in August 2026 and has merged some since. Which is news about an open source project’s governance, not about a console falling.

The architectural advantage those projects exploit, incidentally, has nothing to do with models: the PS5 is x86-64, close to a PC, so the work is more about translating system calls (HLE modules) than emulation in the strict sense.

I am keeping this paragraph even though it weakens the article’s thesis, because that is the point: when a technology is fashionable, it gets credited with results it has not achieved. Telling what is documented apart from what is expected is the only defence we have.

The paradox: more code that recompiles, less code that is faithful

There is serious measurement on the reliability of neural decompilation, and it is less reassuring than the narrative.

The study When LLM Decompilers Recompile More and Preserve Less evaluated 300 functions taken from real libraries on GitHub. Refining Ghidra’s output with an LLM pushes the recompilability rate from 75% to 90%. In the same step, semantic agreement with the original behaviour falls from 74% to 62%.

The mechanism is the opposite of what you would assume. When traditional tools fail to understand a block of memory, they leave a conspicuous placeholder: they tell you where they don’t know. A language model, trained to produce plausible code, fills the hole: it invents a field, infers a type, adds a guard, calls a likely function. The result compiles, reads well, and departs from the original at points nothing flags.

The corollary is the most serious thing in this article. Across 287 functions tied to documented CVEs, up to about one tenth of outputs exhibit “Crash Absence”: the original bug is gone from the reconstructed code. The model saw an illogical assembly block — which was the vulnerability — and silently fixed it, handing the security analyst clean code and false reassurance. The authors themselves warn that the agreement figure is an upper bound while divergence and crash absence are lower bounds: if the real picture differs, it differs for the worse.

That is why research is moving to two-phase architectures such as SK2Decompile (skeleton to skin, ICLR 2026): first recover the control-flow skeleton blindly, ignoring names; only then, with a separate model, apply the “skin” of readable identifiers. Decoupling structure from semantics lifts re-executability to about 69% on HumanEval, against 41.7% for LLM4Decompile. Much better, and still a long way from infallible.

Defensive quality, meanwhile, has not moved

The same pattern repeats in everyday development, and here the data is first-hand. Veracode’s 2026 GenAI Code Security Report measured more than a hundred models on real coding tasks:

Category	Security pass rate
Average across all models	56% (55% the year before)
Cryptographic algorithms	87%
SQL injection	83%
Cross-site scripting (XSS)	15%
Log injection	12%

In plain terms: roughly 44% of tasks produce code with known vulnerabilities when nobody imposes constraints. One percentage point of improvement in a year.

Three details I find more telling than the headline:

Code-specialised models do no better than generalists (51% against 52%). Specialisation improved syntax, not defensive posture.
The best model stops at 68%, and last year’s leader sat at 72%. The ceiling got worse.
Language matters more than model: Python 63%, Java 30%.

The 15% on XSS and 12% on log injection say something precise: agents systematically forget input sanitisation. Not because they can’t do it — ask and they will write it — but because nobody asked, and they optimise for “it works”, not for “it holds”.

The bottleneck moved; it did not disappear

Put the two pieces together and you can see what is actually happening to development teams. Generated code is locally perfect and globally short-sighted: correct inside its own module, blind to the rest of the repository. No agent goes looking for whether that utility already exists.

The duplication numbers showed this before anyone was talking about agents: between 2021 and 2024, duplicated code went from 8.3% to 12.3% of changed lines, while refactoring activity collapsed from 25% to under 10%. More writing, less tidying.

And productivity? The most honest measurement I found is Faros AI’s: teams with heavy AI adoption complete 21% more tasks and merge 98% more pull requests — but review time grows by 91%, and organisation-level DORA metrics stay flat. An experiment across 4,867 developers found no statistically significant gain for those with above-median tenure.

The constraint is no longer writing. It is reviewing, integrating and answering for what has been written. And that part does not parallelise by adding another agent.

So what are you selling?

If any logic running on the customer’s computer can be decompiled, and if the cost of the first 80% has collapsed, then software as something you download and install has stopped protecting a company’s value. What remains is everything an agent cannot extract from a binary.

Historical data. A model reconstructs the recommendation algorithm; it does not reconstruct the petabytes of transactions that trained and validated it. The advantage is no longer the formula, it is the pool it operates on.

Community and network effects. A perfect clone of a messaging platform can be given away. What cannot be given away is ten million people’s decision to be there. The interface copies; relational trust does not.

Infrastructure. Running proprietary logic on your own servers and handing the client only API responses means there is no binary on their machine to reverse engineer. That is the structural reason SaaS wins, quite apart from operational convenience.

On the size of that market I will spare you a figure: I tried to verify one, and 2025 estimates swing between $270bn and $400bn depending on how each firm defines “SaaS”, with 2035 projections running from $1.5tn to $2.9tn. When the spread is twofold, the number informs nothing. The direction does, and it points one way.

And the jobs?

Here it pays to hold two apparently contradictory data points together.

US Bureau of Labor Statistics projections estimate 10% employment growth for software developers between 2025 and 2035, from roughly 1.72 to 1.89 million jobs. Over the same period, Stanford research finds that employment of developers aged 22 to 25 has fallen by nearly 20% against 2024 — and just three days ago CNBC reported that developer job postings are, meanwhile, climbing again.

That is not a contradiction: it is a recomposition. What disappears is the work of pure translation from requirements into syntax, which was the way into the trade. What grows is demand for people who can decide architecture, carry the review load described above, and answer for security. Which opens a real problem that gets too little attention: the ladder broke, not the profession. If the junior rung no longer exists, tomorrow’s seniors do not form on their own.

There is a bright side too, and I say it as someone who works alone with these tools every day: this collapse in costs is the biggest enabler of small businesses in the history of computing. Three people with good architectural judgement and a swarm of agents now do what took twenty people and a funding round ten years ago. The golden cage built around maintaining stagnant architectures is opening, and for anyone with something to build that is not bad news.

In short

Question	Short answer
What collapsed	The cost of an application’s first 80%, not professional software
What held	Domain expertise: colour science, plugin ecosystems, undocumented behaviour
The underrated technical risk	LLMs fill the holes traditional decompilers flag: the code compiles but diverges silently
The security risk	In 10% of cases the vulnerability vanishes from reconstructed code; 44% of generated code introduces new ones
Where the bottleneck went	From writing to reviewing: +98% pull requests, +91% time to review them
What stays defensible	Historical data, network effects, logic that never leaves your servers
What changes about work	Not the number of jobs but their shape: the junior rung broke, the profession did not