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's still programming — the decision-making, the architecture, the validation gates are all mine — but the translation step from concept to compilable syntax is gone.
The receipts sit next to the claim
I built a game in Unreal Engine C++. The agent wrote it; I directed it. I measured 157 human prompts and about 53,000 typed characters of direction over the two weeks (2026-09-07 to 2026-09-20) that produced roughly three-quarters of the project's production C++ — about 90% of its commits. The remaining quarter traces to a two-day scaffold in July whose transcripts no longer exist. The same direction also generated 30,069 lines of automation-test C++ across 115 files, code the agent produced to check its own gameplay output.
Status: in development. The game has a name; it stays unnamed here.
That measurement report is itself a receipt. I built a purpose-made collector and report to reconstruct how the project was actually built, then ran four verification passes on it in a single day. The passes found three real bugs in the collector itself, including one that had reported 13 completed items in a category where the true number was zero, and a separate pass caught two weeks' figures swapped in the prose. I corrected them in place. If your audit tool has never been wrong, you haven't run it enough times.
The project carries 104,912 lines of documentation across 381 files — 1.77 million words — against 81,707 lines of production C++. That's 1.28 lines of documentation per line of code. The largest single documentation bucket, about 40% of all markdown, is written for the agent to read itself back into context at the start of a session, not for a human maintainer. 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.
Documents parse into stable content-addressed blocks so highlighting, notes and audio caching stay aligned through revisions. Notes follow text that moves and are flagged for review rather than silently guessed. Only changed paragraphs re-render. 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 currently pass.
I directed it in English. Claude Code wrote the Rust, the tests, the documentation. The tool I needed and the layer thesis turned out to be the same build.
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, no network required. I wrote an eval to measure story coverage: which beats the model hit, which it skipped. The eval compared the model's own self-reported claim about coverage against a separate, code-computed definition of the same thing, run over a replay corpus.
Agreement came back at chance level, kappa approximately zero. The model's self-reported answer correlated with its position in the response, not with what it actually covered. The eval measured nothing.
I deleted the self-reported field outright and replaced it with the code-computed definition, rather than trying to make the model answer more accurately. The lesson: never let the model grade itself on the exact thing you are measuring. Compute the answer in code wherever the truth is code-computable, and reserve the model for what code genuinely can't determine.
The project's deterministic test suite reached 1,010 tests before I parked it to work on other things. 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: I wanted to be able to have a discussion with the VP about strategic initiatives 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, edited the UI into black-on-black text, refused tasks, and ignored the handbook until a default prompt forced it. Attempt 3 was LEGION v2.0 in Lovable; the GitHub connection failed and the project stalled.
On 10 September 2026, roughly 18 months after I first described it, LEGION was actualized. It finally all came together into a system powerful enough to rebuild Adroit's entire website within a couple of hours. LEGION now runs 64 capability packages across five capability folders, and it's 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.
That game-project measurement report distinguishes a 10.29 billion cache-read token figure — the model re-reading context it has already seen, billed at a steep discount — from the honest 36.8 million generated-token figure. That's a gap of roughly a factor of 280. Both figures, and the hour estimates usually quoted beside them, 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. The only permitted statement is that cost per page is not published yet because there isn't enough measured history. It will release from hold once Content Ops shows measured spend on five or more priced pages.
Measured versus estimated is labeled in the copy, 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. The model writes faster than you would have typed, tests more thoroughly than you would have by hand, and documents as it goes — but 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.
You can see the full measurement reports, test counts, and build specifics on the receipts page.