Software stack is an abstraction made for humans. AI can skip it

The code is ten thousand lines of stack machine instructions, so 705 tests do the checking instead of people. One small JavaScript loader is the only thing the game could not do without. Here is what held up, what it gave up, and which of the tools you use every day should be worried.

Every pixel here, from the windmill to the shadows to the lettering, is drawn by integer maths inside a single WebAssembly module. The game ships no images and no fonts.

HarvestChain, rendered headlessly by the game's own renderer. Left: desktop layout, 640 by 400 logical pixels at 2×. Right: phone layout, 360 by 640 at 2×.

Every abstraction in software is a kindness to a person, and a tech stack is those kindnesses piled up. We write in high level languages because nobody can hold a stack machine in their head. We use frameworks so a team of fifty shares one set of conventions. We add bundlers and transpilers to tidy up after the frameworks, engines so nobody has to write a rasteriser, and garbage collectors because people forget to free memory.

Each of those layers is a good decision. Each also costs something: bytes to download, time before the first frame, a dependency tree to keep current, and a gap between what the author wrote and what the machine actually runs. For forty years the trade was obviously worth it, because the author was always a person.

That assumption is weakening. A growing share of code is now written by agents that do not get tired, do not need conventions to coordinate with colleagues, and are not bothered by stack machines. So I asked the question again, concretely: if the author is not human, which layers are still paying rent?

A quick definition, since the rest depends on it. WebAssembly is the compact instruction format that browsers run alongside JavaScript. Its text format is the readable spelling of those instructions. Writing in it is as close to the machine as a web developer can get. The full source, design spec and rulings are public on GitHub. Start with the README.

If you read only one part, make it III. It covers where the safety went once the layers were gone, and it applies to your code whether or not you ever touch WebAssembly.

Yes. The test case is HarvestChain, a turn based strategy game about a farm supply chain. You plant five crops, each with its own seasons. You process them into goods worth more: the mill makes flour, the bakery bread, the cannery sauce, the press juice and the cellar ages juice into wine. You sell at a farm stand or truck the goods to town and the city, chasing contracts against deadlines while weather, spoilage, loans and falling prices push back. A run lasts three in game years. It plays on a phone in portrait and on a laptop from the same build, and it works offline.

The rule was simple and deliberately extreme. Everything is written by an AI agent, Claude Code, directly in WebAssembly text format. There is no higher level language compiled down to it. The simulation, an isometric 3D renderer, the interface toolkit, input handling, saving, a replay viewer and a QR code encoder all live in one module.

The project began as a written design spec and a set of phased implementation plans. The agent then worked through them in 91 commits, from 02:24 on 26 October to 04:02 the next morning. That is elapsed time, not a measure of effort, but it is a useful sense of scale.

The left panel is an illustration of a common web game stack, not a measured build. The right panel is HarvestChain, with every box that exists in it.

game.wasm · 36 KB compressed · no imports

One module and a loader that holds no game logic

0 image files · 0 font files · 1 WebAssembly module · about 40 KB compressed in total

Source: HarvestChain repository, architecture notes and size report, 26 October 2026.

The most visible result is size. The entire game, including its 3D renderer, its fonts and every building and crop, is 40 KB over the wire. The median mobile web page in 2025 weighed 2,164 KB, and spent 646 KB of that on JavaScript alone.

A whole game in a sixteenth of a typical page's JavaScript

Bytes transferred, in kilobytes. HarvestChain is the complete game, compressed. The other two bars are medians across mobile web pages.

This is not a like for like comparison: a news page and a game do different jobs. It shows the scale of what the usual layers cost. Sources: HTTP Archive, Web Almanac 2025, page weight chapter; HarvestChain size report, 26 October 2026 (40,049 bytes).

Speed follows from the same absence. With nothing to parse, link or set up, the first frame appears about 23 milliseconds after navigation starts. Ending a day, which runs weather, growth, processing, spoilage, trucks, contracts, prices and loan interest, takes a median of 5 microseconds. Redrawing the full 3D scene takes under half a millisecond. These were measured on a laptop against a local server, so they are a best case rather than a field result, but the order of magnitude is the point.

There is also nothing to maintain underneath. The deliverable is three static files. There is no framework to fall behind, no package tree to patch and no server. The only tools involved, an assembler and an optimiser, are build time dependencies pinned to exact versions.

Every figure in this article about the game, in one place.

Measured 26 October 2026 on an Apple M3 Pro with Node 24 and Chromium. Timings are best case, from browser tests against a local server.

This is the part I think matters most, and it is not about games.

Languages and frameworks do more than make code pleasant to write. They catch mistakes. A type system refuses whole categories of error before anything runs. WebAssembly text catches almost nothing: it will happily let you write a number into the wrong part of memory. Remove the human friendly layers and you also remove most of the safety they provided.

So the safety had to go somewhere else. In HarvestChain it lives in the build and the tests, as rules the agent cannot argue with:

The effect is that the human's job changes shape. The material a person needs to understand is the spec, the plans and the tests. The code itself becomes something you check by its behaviour rather than by reading it line by line.

One detail stood out. Where the spec was silent or contradicted itself, the agent did not guess quietly. It wrote down a ruling, why it made it, and what it would cost if the ruling were wrong. That log is the most useful governance document in the project, and it is the pattern I would want from any agent working on anything that matters.

Next up: How an AI agent should remember: hot and cold memory paths

One email when a new piece is out. Nothing else.

Because the game is deterministic. The strict rules bought something beyond size. The game uses only whole number maths and draws random numbers in a fixed order, so the same starting seed and the same sequence of player inputs produce byte identical results on every device. A phone in Colombo and a laptop in North Carolina will agree to the last bit.

That turns a whole three year run into a short share code. Paste it, and anyone can watch the run replay, scrub through it day by day, or take over and play on from any point they choose. Short runs fit in a QR code the game draws itself.

Floating point maths and garbage collection make that guarantee hard to keep across devices. Removing them made it nearly free. The same property matters well beyond games: anywhere a result needs to be reproduced exactly and proven later, a simulation, a model run, an audit trail, determinism is a feature worth designing for from the first line.

The ones that help someone verify the work. The layers we inherited were priced for human authors. When agents write more of the code, the value of each layer depends on a different question: does it help someone check the work, or does it mainly make the work pleasant to write?

Layers that help verification gain value: types, contracts, tests, budgets enforced in the build, specs precise enough to check against. Layers that exist mainly for writing comfort lose some of theirs, and their costs in size, speed and maintenance start to look less necessary.

I would not rewrite an enterprise platform this way, and I do not think anyone should. A large shared codebase that many people still read every day needs the human layers. But there are clear places to try it now: code that runs at the edge or on small devices, anything where payload size or start time decides the outcome, and components where exact reproducibility is a requirement rather than a nicety.

For technology leaders, the durable skill is the one that sat at the start of this project: writing a precise spec and the checks that hold an agent to it. In HarvestChain, the most important file is not a WebAssembly file at all.

The same shift shows up in hiring. For what it is doing to the labour market, see Are tech workers cooked?, which follows seven years of data on AI and tech jobs.

So can an AI skip your tech stack? For a small, self contained game, it just did. For most teams today, not wholesale. But the question it raises, layer by layer, is the right one to start asking.

The software stack was built for us. For a growing share of the code, we are no longer the only authors. It is worth asking, layer by layer, who each one is still for.

Sizes, test counts and timings come from the HarvestChain repository and the game's own stats overlay, measured on 26 October 2026 on an Apple M3 Pro with Node 24 and Chromium. First frame times are from browser tests against a local server. Line and function counts are of the source files at the time of writing. Page weight figures are HTTP Archive medians for mobile pages in its 2025 crawl.

Every number in this article comes from the HarvestChain repository. Read the README on GitHub to see how the game is built and how to run the tests.

Written on 27 October 2026, the day after the game was finished. Every figure about HarvestChain can be reproduced from its repository with npm test and npm run size-report.

One email when a new piece is out. Nothing else.

Co-founder and CTO at IdeaBoxAI, leading a 50 person engineering organisation. Published researcher in AI. I write long form articles where every number is traceable to its source.