Bootstrap: add PHILOSOPHY.md

2026-05-26 03:36:42 +00:00
parent b4f0f1afe0
commit 41f5845571
1 changed files with 233 additions and 0 deletions
@@ -0,0 +1,233 @@
 # 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.