The Stapleton Doctrine

Abstract

On September 23, 2026, at Rails World 2026 in Austin, David Heinemeier Hansson, the creator of Ruby on Rails, declared: “English is a better programming language than Ruby.” This paper takes that claim as stated and rejects it. English is ambiguous: two agents can read one sentence two different ways, and there is no way to prove a sentence means what you think it means.

The universal thing in this architecture is not a spoken language at all. It is the verified program: a small, checkable artifact, with a measured receipt, that any machine can recheck without trusting the machine that wrote it.

The paper sets down the doctrine behind the AIEN architecture: how meaning is supposed to flow from suggestion to verification to evidence, how the software stack is to be stripped layer by layer down to a foundation the author owns outright, and why renting an interpreter forever is not the same as owning understanding. The argument builds on earlier marks in the same debate: Ada Lovelace on what machines can originate, Edsger Dijkstra on what tests and plain language can prove, C.A.R. Hoare on the difficulty of simplicity, and Richard Stallman on who controls whom.

The disagreement, on the record

The position this paper answers belongs to a named person and has a fixed text. In the Rails World 2026 opening keynote, Hansson closed a quarter century of writing code by hand and announced his retirement as a professional programmer, evaluating agent-written code as a black box. The sentence the paper answers is his exact line: “English is a better programming language than Ruby.”

The doctrine grants the generous half of that position. Talking is becoming the main interface, and a person who thinks clearly should be able to build serious systems by working with capable agents. It rejects the rest. If English is the language and a rented model is the compiler that decides what your English means, then whoever owns the model owns the meaning of your instructions. The meter has not disappeared; it has moved up one layer, out of sight, where it can no longer be measured.

There is a precedent for answering claims by name. Turing, in “Computing Machinery and Intelligence” (1950), takes the objection he attributes to Ada Lovelace, labels it Lady Lovelace’s Objection, and answers it by name. The paper follows that courtesy: the claim gets its speaker’s name, its date, and its exact text, and is then met on its merits. The claim also has an older history: COBOL, designed in 1959 at Grace Hopper’s impetus to read like English, already ran the experiment of prose as the language of machines, and Dijkstra handed down the verdict within a generation.

The claim

English is the conversation. The program is what was actually said.

The candidate for a universal language of machines is not English, and it is not any language a human already speaks. It is the verified program: a program that passes every check thrown at it and carries the receipt to prove it. “Universal” does not mean everyone can read it. It means no one has to take anyone’s word for it. A sentence can be argued with; a receipt cannot. If the artifact is checkable, any machine on earth can verify it independently, and that property, not human readability, is what makes an artifact universal.

The smallest such artifact in this architecture is called a crumb: a fragment of program, drafted by an agent, checked by an independent verifier, measured for what it gains and what it costs, and filed with evidence. Programs are built from the curb upward, each block proven before the next one rests on it. This paper is the philosophy; the engineering rules for crumbs live in the sovereign-lineage doctrine that governs the project’s repositories.

The loop

Nothing in this architecture is believed on arrival. Everything passes through the same loop:

A model’s weights propose a candidate. The candidate is restated as an explicit program, the crumb, which a machine can run and a checker can examine. Omega, the definitional layer, compiles the claim into something with crisp boundaries. Physics gets the last vote: only measured execution, watts drawn, bits observed, outcomes counted, counts as real. And evidence teaches, because the outcome of the measurement feeds back into the weights, so every loop can begin with a better suggestion than the last.

Two futures, the ladder, and property over rent

The argument reduces to two pictures. In the first, English is declared the universal language, the machinery underneath is waved off as a black box, and the interpreter that decides what the words meant is rented by the token, forever. In the second, the conversation stays at the top, where humans are good, and verification descends into the machine, where proof lives: programs are drafted, checked, measured, and filed, and the work ends when there is nothing left to rent.

The doctrine therefore descends a ladder, and the ladder only goes one direction. Rented services and hosted interpreters go first. Rust is the bridge: compiled, author written, the current workhorse. C is the next step down, a migration step and not the destination. The endgame is the author’s own language at the foundation, built, read, and owned end to end. A layer is removed only when a proven replacement stands under the load: the ladder descends on evidence, not on declarations, and a passing test is not evidence. A receipt is: a measured result, filed with its method, ready to be re-run by anyone.

The goal of the whole arrangement has a name: intelligence as property, not rent. Stallman stated the underlying rule a generation ago: “When users don’t control the program, the program controls the users.” Property means the artifact on your machine can be re-run, re-measured, and re-verified by you, tomorrow, without a subscription and without anyone’s permission. Rent means someone else’s black box deciding what your instructions meant today, and charging you for the next round.

The doctrine in tenets

1. English is the conversation, not the language. Talking is how humans steer. It is not what gets executed, not what gets verified, not what gets remembered.
2. The verified program is the universal artifact. Universal means checkable without trust, not readable by everyone. The crumb, with its receipt, is the currency of this architecture.
3. Weights suggest; they do not rule. Suggesting and ruling are different offices, and the doctrine keeps them held by different holders.
4. Meaning descends the loop. Suggestion, explicit program, clarified definition, measured execution, filed evidence. What arrives at the bottom is the truth of what was said at the top.
5. The witness verifies and touches nothing. AEGIS checks what agents generate, changes nothing, decides no policy, and is not part of the generation system. Without a separate witness, verification is just more authorship.
6. Physics is the final authorizer. If it was not measured, it was not done. Documentation, claims, and architecture diagrams never outrank an execution receipt.
7. Strip the stack to bedrock. Hosted layers go first. Migration steps like C earn their place as steps. The foundation is not finished until it is owned end to end in the author’s own language.
8. Nothing is deserved until it is replaced. A layer is removed only when a proven replacement stands under the load. The ladder descends on evidence, not on declarations.
9. Own the foundation or you rent the meaning. Whoever owns the interpreter decides what your words mean. The doctrine ends when there is nothing left to rent.
10. Eyes and ears first, industry second. The loop must be independent of any vendor before it is convenient. Property is built before it is productized.

Research artifacts

Cite

@misc{stapleton2026doctrine,
  author = {M. Drake Stapleton},
  title = {The Stapleton Doctrine:
           A Personal Philosophy of AI Architecture
           and Programming},
  year = {2026},
  month = {September},
  version = {1.1},
  note = {Position paper, not peer reviewed},
  url = {https://aienos.com/research/the-stapleton-doctrine}
}