Revised 9 October 2026: the receipts section now covers every project, not only the game. The original version is in the site's history.
Assembly let you write MOV instead of 10110000. C let you write for loops instead of tracking jump addresses by hand. Python let you say import requests instead of managing sockets and HTTP yourself. Each layer moved work up the stack. You still had to know what you wanted the computer to do, but you could say it in words closer to your own thinking.
English prompts are the next layer in that line. I can now direct Claude Code through a build in my native language instead of translating my intent into Python or TypeScript syntax first. The agent writes the code, tests and documentation; I direct, decide, purchase and validate. It is still programming. The decisions, the architecture and the validation gates are all mine. The translation step from concept to compilable syntax is gone.
"I can code in English now" is also the most overclaimed sentence in tech. So the claim does not get to stand on its own here. The receipts sit next to it.
AI is writing code faster than anyone could possibly read it. Software engineers are increasingly going to be the ones keeping a system running that no human ever actually saw get written.
The receipts, across everything
The first version of this article made the case from one project. One project is an anecdote. Here is the whole portfolio.
The builds page lists twelve software projects, the earliest from October 2024. Six are live or shipped. Content Ops and LEGION are live, running real work. Sadyr is a live platform with two working demos, not yet sold as a product. Audio Apothecary, the Brain Vault and Cadence are shipped, each to an audience of one: me. Two are in development, the game and Milkman. Four are parked: the creature battler, the interactive fiction engine, the job search pipeline and the on-device assistant. Every one of them was built the same way. I directed in English; the agent wrote the code.
Across those twelve projects sit more than 8,000 automated tests, and the agents wrote those too, to check their own work. That figure is the sum of each project's measured or last recorded test count. It leaves out the Godot project's self-reported counts, which were never re-run, and the game's spec files, because a spec file is not one test. The per-project table, with a label on every row, is on the receipts page.
Lines of code are the number people quote. Across the twelve it comes to roughly 525,000 lines of code and tests, approximate because each project was counted differently. Roughly 150,000 of those lines are tests, and that is the part I care about: a test is a claim about the code that the code has to answer for.
The worked example: the game
I built a game in Unreal Engine C++. The agent wrote it; I directed it. Status: in development. It has a name; it stays unnamed here.
I measured 157 human prompts and about 53,000 typed characters of direction over the two weeks (7 to 20 September 2026) that produced roughly three-quarters of the project's production C++. The remaining quarter traces to a two-day scaffold in July whose transcripts no longer exist. The same direction also produced 30,069 lines of automation-test C++, code the agent wrote to check its own gameplay output.
The measurement report is itself a receipt. I built a collector to reconstruct how the project was actually built, then ran four verification passes on it in one day. They found three real bugs in the collector, including one that reported 13 completed items where the true number was zero. I corrected them in place. If your audit tool has never been wrong, you haven't run it enough times.
The project carries 1.28 lines of documentation per line of production C++, and about 40% of that markdown exists so the agent can read itself back into context at the start of a session. In a plain-language layer, the prose is the source and the C++ is the compiled artifact underneath it.
Proofreading by ear instead of by eye
I'm dyslexic. Proofreading my own writing is the exact task my brain is worst at: the eye skips, autocorrects, and fills in what it expects to see. So I built Cadence, a desktop app that lets me proofread by ear instead.
It runs fully local on a consumer GPU, no account, no cloud upload, measured at 6.94 hours of narration in 98.2 minutes of GPU time, 0 failed segments. 368 backend tests pass. I directed it in English; Claude Code wrote the code, the tests and the documentation. Status: shipped, for my own use.
What broke and how I fixed it
Not every number survives scrutiny. I built an on-device interactive fiction engine, a narrative system that runs entirely local. I wrote an eval to measure story coverage: which beats the model hit, which it skipped. It compared the model's own self-reported coverage against a code-computed definition of the same thing, run over a replay corpus.
Agreement came back at chance level, kappa approximately zero. The model's answer correlated with its position in the response, not with what it actually covered. The eval measured nothing.
I deleted the self-reported field and replaced it with the code-computed definition. Never let the model grade itself on the exact thing you are measuring. Compute the answer in code wherever the truth is code-computable.
The deterministic test suite reached 1,010 tests before I parked the project. Status: parked.
LEGION, about the same time the industry converged on the architecture
In March 2025 I started building LEGION. The vision was simple to say: discuss strategic initiatives with the VP while the research, problem solving, asset acquisition and fulfillment were handled by the AI organization without further input from me.
Google Cloud published "agentic orchestration has emerged as a new paradigm for LLM-powered applications" on 24 March 2025, about the same time I was sketching LEGION's first attempt. OpenAI had released the Responses API and Agents SDK two weeks earlier (11 March), citing customers struggling with custom orchestration logic. Google Cloud Next followed on 9 April with the Agent Development Kit and the line "Every enterprise will soon rely on multi-agent systems." I was building around the same architecture in the same weeks the industry was converging on it, and well before it had a common name.
My first two attempts failed. Attempt 2 was Docker + FastAPI + LangChain; agents lost work in wiped containers and ignored the handbook until a default prompt forced it. Attempt 3 was LEGION v2.0 in an online vibe-coding tool; the GitHub connection failed and the project stalled.
On 10 September 2026, roughly 18 months after I first described it, LEGION was actualized: a system powerful enough to rebuild Adroit's entire website within a couple of hours. It now runs 64 capability packages across five capability folders, and it is the system I use to build everything else.
Anthropic published "Effective harnesses for long-running agents" on 26 November 2025; OpenAI named "harness engineering" as a discipline on 11 February 2026. The abstraction I was building in March 2025 became the industry's named layer about eight months later.
Status: live, running production work.
Every number labeled
Before repeating any AI usage number, ask what it is counting and what window it covers. Most published figures answer neither question.
The game's measurement report distinguishes a 10.29 billion cache-read token figure, the model re-reading context it has already seen, from the honest 36.8 million generated-token figure: a gap of roughly a factor of 280. Both cover only 14 of the project's 79 calendar days, and I state that every time.
Content Ops, the long-form drafting engine, began capturing cost data only at version 5.10. It has no measured history yet, so I do not publish a cost-per-page number until it shows measured spend on five or more priced pages.
The test total above follows the same rule. Where a project's own documents disagreed, I took the highest figure recorded in the repository, or the measured count if higher, and left out anything that could not be sourced. Measured versus estimated is labeled, never rounded up, never silently upgraded to fact.
What the layer means for builders
English is a programming language now, but it is still programming. You still decide what to build, validate that it works, purchase the infrastructure it runs on, and own the outcome. Direction, decisions and verification are yours.
Assembly didn't replace the people who wrote machine code. It moved them. C didn't replace the people who wrote assembly. It moved them. Python didn't replace the people who wrote C. It moved them. The plain-language layer does the same thing every layer before it did: it moves work up the stack, and the people above it get more done.
That is why the number I trust is the test count, not the line count. A layer you can't verify is a layer you can't trust. The full measurement reports, test counts and build specifics are on the receipts page.