The requirement nobody removed
Sixty years of computing history, one unbroken prerequisite — and the argument for why removing it is an architectural problem rather than an interface one.
The founding observation
For more than sixty years, computers have required people to think like software designers before they could get work done. Programming languages, graphical interfaces, forms, workflows, and even prompts all reduced the effort — but they never removed the requirement.
WAR Doctrine 004, The Entry Doctrine §2 · ratified for external use, 24 July 2026
People already possess complete intent. The shop owner knows the credit rules. The compliance officer knows the policy. The founder holds the full specification in their head. What they lack is implementation vocabulary — a programming language, a prompt format, fluent technical English, a platform's workflow.
Every AI system built to date treats that lack as the human's deficiency to fix. We treat it as the architecture's job to eliminate. The graphical interface did not make office workers smarter; it made their existing competence sufficient. This is that inversion applied to the AI era — and this time the inversion is not an interface metaphor but a computational architecture.
Four problems are one problem
Ask the same AI system the same question twice and you can get two different answers.
Deploy an AI agent in an enterprise and nobody — not the vendor, not the compliance team, not the model itself — can explain exactly why it did what it did.
Build on one model provider and you are locked in; switch providers and your prompts break.
Give a system your intent, and it receives your words.
Every AI system ever built runs on language. Language is a lossy compression of what you actually want.
Every hallucination, every inconsistent answer, every unexplainable decision is that loss showing up downstream. These are not four problems with four fixes. They are one problem with one fix, and the fix is architectural: stop computing on language.
Intent-Native Computing, defined
A model of computation in which human intent, rather than language, is the unit of work. Intent is captured once into a typed, versioned, language-free representation; everything downstream of that representation is deterministic, inspectable and provider-independent.
The progression, as frozen across all three Genesis volumes
| Era | What the user had to think in | What removed the burden |
|---|---|---|
| MS-DOS | DIR COPY CD FORMAT | The graphical interface |
| Procedural programming | Memory layout, control flow | Object-oriented programming |
| Infrastructure | Servers, provisioning | Cloud computing |
| AI-assisted engineering | Prompt syntax | Intent-Native Computing |
This is the table we use, and the only one. A looser ladder — Assembly → GUI → Internet → Cloud → AI — mixes abstraction layers with infrastructure eras with technologies, and a reader who thinks in these terms will notice.
Assembly made instructions the unit of computation. SQL made relations the unit. Kubernetes made containers the unit. Intent-Native Computing makes intent the unit.
Three barriers, three transfers
The Genesis trilogy in one line each. Each volume names a hidden tax and the transfer that removes it.
| Volume | The hidden tax | The transfer |
|---|---|---|
| Interaction | Prompt authorship — incantations composed for the machine | The prompt becomes internal serialization |
| Access | English authorship, foreign cards, dollar pricing | Understanding at the door, one language-free graph inside |
| Trust | Faith — acceptance of what cannot be inspected | The burden of proof moves to the runtime |
A person thinks in their own language, expresses intent without incantations, pays with their own money, and verifies with their own eyes.
What this is, and what it is not
A new category is always pulled toward the nearest familiar one. Naming the pull is cheaper than arguing with it later.
Is
- An intent runtimeThe layer between a person's intent and any AI model.
- The first implementation of Intent-Native ComputingIntent, not language, as the unit of computation.
- A determinism boundaryNondeterminism ends at the Intent Graph.
- Language-independent by designThe graph never remembers what language it came from.
- Provider-agnostic by constitutionThe best model for the task, never a captive one.
- Domain-agnostic at its coreCoding is the first plugin, not the definition.
- A capability platformVersioned, conformance-tested units of business function.
- A transparent software construction engineConstruction is narrated, not hidden.
- Observable by constructionEvery binding decision is an inspectable object.
- Built for the verifier who is not an authorOne graph, read at the altitude each person occupies.
Is not
- Another AI IDE or coding assistant
- Another prompt editor or LLM wrapper
- A single-provider product
- A translation product
- An observability dashboard beside a black box
The full fence, including the India-only and model-interpretability guardrails, is kept in llms-full.txt.
The litmus tests
Three questions every architectural decision has to survive. They are in the corpus because a filter with no teeth is a slogan.
Would this decision still make sense if WAR never had a Coding Agent?
Does this make the construction more verifiable by the builder — or merely more reassuring to the buyer?
Does this interface make the human think more like a computer, or does it make the computer understand more like a human?