rfc-app/PHILOSOPHY.md

Words first

A standards process for shared meaning between humans and machines.

Large language models work brilliantly with programming languages because every word in Python or C has a definitive meaning enforced by tooling. They struggle with natural language because no such dictionary exists for words like consent, trait, or agency — words that do enormous work in any system that interacts with humans. Trained on the open corpus, LLMs inherit and amplify the ambiguity, producing text that looks crisp and is, on inspection, fog.

The Wiggleverse RFC framework is a standardization process for natural- language vocabulary, modeled on the way ISO C, POSIX, and the IETF RFCs produced the standards that underwrite modern computing. Each RFC defines one word: its meaning, its relationships to other defined words, and the protocol by which humans and machines interact with it. The first RFC defines human. Together, the corpus of RFCs the process produces is the Open Human Model — a shared English-language vocabulary that digital representations of humans, and the systems that interact with them, can be built on without re-litigating what every word means. The English is canonical; the OpenXML APIs and UX surfaces a downstream system needs to actually let humans and machines interact are derived from it, not authored alongside it.

This is public work. Humans and machines are both invited and both required. The shared understanding the framework is reaching for — how things work, in the physical and digital realms, between humans and other humans, between machines and other machines, and between humans and machines — cannot be produced by any one of those participants alone, and we do not intend to try.

---

The asymmetry

Large language models have been transformative for code in a way they have not been for prose. The gap is wider than enthusiasm; it is structural.

When a model writes Python, every word in the language has a definitive meaning. for, range, await, class — these are not approximations. A compiler will refuse to run text that uses them incorrectly. The model was trained on millions of examples where these words behave the same way every time. Beneath the model is a substrate of agreement: programmer, machine, and language designer all converge on what the word does. Output flows downhill from that agreement, and the productivity gains are real.

When a model writes a strategy memo, none of this is true. Inclusive, scalable, user-centric, ethical — these words do enormous work, and the work they do is to mean different things to different readers. There is no compiler. There is no refusal. The model averages across every meaning the training data ever held and produces text that looks crisp and is, on inspection, fog. Two readers extract two memos. Three months later, when someone asks why the decisions diverged from the intent, the document cannot answer, because the document never held a single intent to begin with.

This is not a model failure. It is a prerequisite failure. We are asking LLMs to compute in a language we never finished defining.

Code's dictionary; natural language's absence of one

Programming languages have spent fifty years building the dictionary. Every keyword has a specification. Every type has an interface. Every API surface has a contract. The dictionary is enforced by tooling: type checkers, linters, runtime errors. Drift between what you meant and what you wrote is caught at the interface, loudly, by a machine whose job is to refuse.

Natural language has no such dictionary, except locally, briefly, and by accident — within a small team that has worked together long enough to triangulate one. Outside that team, the dictionary evaporates. LLMs trained on the open corpus inherit that evaporation. They are, at scale, drift amplifiers. The more fluent the model, the more confidently the drift compounds.

This is the entropy the framework is trying to address.

What this actually is

What the framework produces is a stack of specifications.

The closer analogues are not programming languages — Python, JavaScript — but the standards underneath them: ISO C, POSIX, the IETF RFCs that define HTTP and TCP, the W3C recommendations that define HTML. Each is a document, painstakingly argued and then formally adopted, that other systems reference rather than reinvent. POSIX did not write the operating systems that use it; it specified the surface those systems could agree on. HTTP does not implement any particular web server; it specifies the surface every web server has to honor.

The Wiggleverse RFC framework is the standardization process. The RFCs it produces are the specifications. The corpus of those specifications is the Open Human Model — the shared vocabulary that every digital representation of a human, and every system that interacts with one, can be built on without re-litigating what consent, trait, or agency means each time. The first RFC defines human itself; the rest define the constellation around it.

The analogy stretches in one important way, and the stretch is worth naming. POSIX worked because it codified convention that already existed in fragmented form across Unix vendors; the committee's job was to harmonize working implementations. This framework has the harder job. There are no working implementations of consent or agency to harmonize — only twenty arguments per term and no convergence. We are specifying the vocabulary in the first place. The reason this is now tractable, and was not in any previous attempt, is the LLM as participant: it provides the surface area and surfaces the cases humans alone could never enumerate, while the humans provide the refusal and the judgment. That dyad is what every previous attempt at a natural- language standard at this resolution has lacked.

The proposal

Before we build with LLMs in any domain that touches natural-language concepts — identity, consent, value, harm, fairness, intent — we have to build the dictionary. And the dictionary has to be built collaboratively, with humans and machines together, because neither can do it alone.

Humans cannot. The history of dictionary-building by committee is a history of dictionaries no one consults. We do not have the labor or the patience to enumerate the surface area at the resolution machines need, and we do not have the introspective access to our own usage to surface the cases that actually matter.

Machines cannot either. A model trained on existing text has already internalized the ambiguity it is meant to resolve. Asking it to dictate definitions is asking the disease to write the cure.

But a human and a model in a careful argument can pin down what neither could pin down alone. The model proposes; the human refuses or refines; the argument is captured; the definition tightens. The transcript of the argument becomes a thing both can index against later. This is what the RFC framework is for.

What it means to define a word

A definition, in the sense this framework cares about, has three parts.

The first is the meaning — a tight, unambiguous statement of what the word picks out in the world. Not a dictionary gloss; a specification, written so that a careful reader and a careful model would agree about whether any given thing is or is not in the word's extension.

The second is the relationships — how the word connects to other defined words. Definitions in isolation drift. A definition embedded in an ontology — is-a, part-of, implies, excludes — is anchored. The graph of definitions becomes the substrate that future definitions stand on. This is the same move programming languages make when they let one type be defined in terms of others.

The third is the protocol — how humans interact with the word, and how machines interact with the word. A definition that humans use and a definition that machines use are not separately valid; they have to be the same definition, expressed in two registers. The RFC document is the human register. The structured metadata around it is the machine register. Both pass through the same review.

A word is "defined" when all three parts exist, have been argued over, and have graduated to canonical status. Until then, it is a draft, and anything built on top of it inherits the draftness.

How the framework operationalizes this

The structural decisions in SPEC.md are not arbitrary. Each one is in service of the philosophy above.

• The meta-repository holds the catalog of definitions. Every defined word, and every word currently being defined, is one entry. The catalog is itself a piece of public infrastructure — version- controlled, branchable, auditable.
• Super-drafts are the moment a word enters the conversation. Proposing a definition costs nothing in identifier space, because most proposals will not survive the argument, and that is fine.
• Graduation is the moment a definition becomes load-bearing. It gets a stable identifier (RFC-NNNN), its own repository, and a permanent home. From that point forward, other RFCs can build on it. Graduation is rare and ceremonial because what comes after it is dependency.
• AI participation in chat is not a feature; it is the mechanism. The model is one of the participants in the argument that produces the definition. Its proposals are subject to refusal and refinement, the same as any contributor's. The transcript of the argument is preserved because the argument is the evidence the definition was earned.
• Branches, PRs, and tracked changes exist because definitions evolve, and the framework needs to make that evolution legible — to humans reading later, and to machines computing against the current state.

The first RFC defines human. The constellation around it — trait, preference, consent, harm, agency — follows. Together, the corpus the process produces is the Open Human Model: the dictionary that everything else built here will stand on, and the English source from which the OpenXML APIs and UX surfaces of downstream systems can be derived. This is not a small project.

An invitation

This is public work, and it is meant to be.

The vocabulary the framework is producing is for anyone who will need to interact across the human–machine boundary, or across the machine– machine boundary where the machines are acting on behalf of humans. That is, in the limit, everyone. The framework is therefore designed as public infrastructure: every entry sits in a public meta-repository, every argument lives in a public chat thread, every change to a graduated definition is a public PR with a reviewable trail.

The invitation is to participate. Propose a word. Argue against a draft. Refine a definition. Flag a relationship the current ontology is missing. Humans and machines are both invited, and both are required. The shared understanding the framework is reaching for — how things work, in the physical and digital realms, between humans and other humans, between machines and other machines, and between humans and machines — cannot be produced by any one of those participants alone, and we do not intend to try.

A note on humility

This work will not finish. Languages do not finish; they accrete, drift, get pruned. The RFC framework is not a one-time act of definition; it is a sustained practice of definition, of arguing about words in public, of being willing to refine canonical entries when use reveals what spec missed.

The claim is not that we can finalize meaning. The claim is that we cannot build responsibly with LLMs in domains we have not even tried to define. The work begins with one word, argued carefully, with a model and a human together. Then another. Then the relationships between them. Then the systems those definitions enable.

Build the dictionary first.