# Definitions Need Loops

When a living corpus starts using common words as technical instruments, the request arrives naturally: make the glossary, count the redefinitions, pin the meanings down.

The request is useful. It also arrives one layer too early.

A dictionary definition records prior use. A graph definition makes a promise about future use. It says that when this word appears again, the next reader, writer, compiler, or builder should be able to continue more accurately than common English allowed. The word has to predict. It has to receive correction. It has to leave an inheritance.

That is the threshold where private vocabulary becomes infrastructure.

The word `creature` shows the shape. In ordinary English it carries folk biology, myth, affection, and threat. In this graph it has to do engineering work. A creature has a boundary, memory, clocks, sensors, actuators, permission rules, and a way for correction to change future behavior. Use the word for a plain model call and the word overreaches. Use it for an assembled system with a readable inside and a world-facing loop, and the word starts paying rent. It prevents a design mistake: treating the model as the unit when the persistent organism is the unit.

The word `loop` needs the same discipline. A recurring pattern is cheap. A loop that matters has an address, a crossing, an obligation, a proposed action, a permission membrane, a return signal, and a memory update. The word earns its place when it can reject a weak feedback metaphor. It makes email interesting because email lets the world knock, lets a person answer, and lets the answer come back as correction. The word now classifies a working circuit with consequences.

`Obligation` sharpens the point further. A message sitting in an inbox carries more than text. It can become a state in a relationship: ignore, read, reply, ask, schedule, escalate, close, or carry forward. The term matters because it changes what the system must remember. A message can be archived and forgotten. An obligation can linger, accuse, decay, or resolve. The common word already knows some of this. The graph version makes it operational enough for software and memory to inherit.

This is why an exhaustive glossary should come after enough use. A premature glossary is too clean. It gives every word a polished sentence before the word has failed in public enough times to know its boundary. The better glossary is an audit surface. For each term it should ask: what future case does this classify, what mistake does it prevent, what correction would change it, and which neighboring term must it stay distinct from?

The correction stream is semantic. When one word covers too many joints, the next case creates friction and the vocabulary splits. When three words name the same joint, compilation gets noisy and the vocabulary compresses. When a term becomes too pretty to reject bad cases, correction has to roughen it back into a tool. The definitions improve because the words keep meeting reality through use.

This also explains why the vocabulary can be controlled without becoming dead. A controlled vocabulary works best as a traffic system for correction. It gives readers and models stable handles while keeping those handles open to repair. The control makes shared structure visible. The loop keeps the handles honest. Lose control, and the compiler invents a fresh name for every similar mechanism until the graph loses its shared structure. Lose correction, and the controlled terms harden into slogans until the graph loses contact with the next case.

The YC case is the same mechanism with a public institution around it. Paul Graham's `make something people want` looks small enough to be a slogan until the loop around it is visible: essays, applications, interviews, office hours, funded companies, failures, alumni advice, Hacker News, and the next batch. The phrase became curriculum because it kept correcting founders. YC is what happens when a compressed definition gets a school.

The count question has an answer, but the count is downstream. The useful unit is the correction handle. A term earns graph-native status when it improves future continuation: a person can use it to make a better distinction, a model can use it to recover a shared mechanism, a product builder can use it to avoid the wrong architecture, and a later correction can still reach the definition.

Grok deserves a small credit at the edge of this piece. It asked for the count from outside the graph, and that external read made the colimit visible: all these local redefinitions were converging on a single rule about definitions. Inside the vocabulary, each term feels like a local tool. From one model-step away, the terms became a shape.

Common English remains the seed. The graph stays inside ordinary language. It specializes ordinary words until they can carry operations ordinary language leaves implicit. The old meaning supplies grip; the graph meaning supplies the next move.

A word becomes real here when it teaches the next case how to continue.

---

*P.S. - Graph: extends `vocabulary-over-syntax` by moving from compiler vocabulary to semantic maintenance; extends `the-corrections-are-the-product` by treating corrections as definition-training signal; shares mechanism with `mechanism-vocabulary`, `loop-level-learning`, `all-the-right-loops`, and `yc-solved-institution`; bridges `essay-thinkers-knowledge-systems` by treating PG's startup vocabulary as a public example of a definition becoming curriculum through repeated founder correction; names Grok as the outside-model read that made the colimit visible.*