Naming the latent

And whatsoever Adam called every living creature, that was the name thereof. Genesis 2:19, King James Version

The color you can't see

Ancient texts almost never mention blue. Homer's sea is wine-dark and his sky is bronze. Blue was a shade of black, or of green, until someone gave it a name. Color words arrive in a near-universal order across languages: black and white first, then red, then green and yellow, and blue only after those. That's the part that got me. A color is practically not visible until it's articulated.

There's a people in Namibia, the Himba, whose language cuts the spectrum differently from English. It has five basic color terms, and their boundaries don't match ours. Speakers tell colors apart faster and more accurately across a boundary their language marks than within one of its categories. The first time I heard this, the reply was that a trained Westerner can tell the greens apart too. That hit the nail. Trained means the difference is already articulated in your head. The eye always saw the two greens. The pattern wasn't visible until it had a name.

Where I started: a language with no shadows

I got here by a strange road. I'd been reading about Ithkuil, the constructed language built for maximal precision, where the grammar forces you to mark things English leaves open: whether you saw it yourself or heard it, whether you meant to, whether you're describing a thing or your reaction to it. My first idea was blunt. Language models train on the whole dump of languages, styles and slangs on the planet. Rearticulate that corpus in Ithkuil, train on the clean version, and the relations between concepts get cleaner too. Maybe the model gets smarter.

That idea doesn't survive contact. The information isn't missing from English; a model infers evidentiality and intent from context. Whoever rewrites the corpus already needs the understanding you're trying to create. And the moment you rearticulate a poem, you have to decide things the poet left deliberately open. "The woods are lovely, dark and deep": is lovely a property of the woods or your reaction to them? Do the woods draw you or threaten you? Mark it and you kill it.

So Ithkuil doesn't add subtlety. It adds explicit distinctions that disambiguate. That's a gain where ambiguity is a defect, in legal, scientific and technical text, and a loss where ambiguity is the instrument. It works better as a vagueness detector than as an expressive tool: trying to say something in it, you find out which parts of your own thinking you never decided.

Precision is not coverage

Here's the thought experiment that moved me off the idea. Take a model with a trillion parameters and train it on nothing but children's stories in English. A gigantic corpus, simple concepts. All those parameters go into deciphering relations, and the concepts live in those relations, but the concepts only exist in the corpus. The model is limited. And what limits it is the content, not the language. The stories are in English, and so is quantum physics. Translate every story perfectly into Ithkuil and the model still doesn't know physics. Precision and coverage are two different axes, and the intelligence I'm after lives mostly on coverage: how many distinct situations the model has seen.

What precision buys is efficiency. A model spends capacity learning that "bank" has several senses. If the language marks it, that work disappears, so the same stories in a more precise language could fit in fewer parameters. Fewer, but by how much? Nobody knows, because nobody has run the experiment. There is no Ithkuil corpus. The indirect evidence, that some languages cost more tokens per sentence in today's models, mixes two causes: how the language is built and how little data it has, since the tokenizers were trained mostly on English. And the two costs don't scale the same way. Learning the morphology is a fixed cost, paid once. The benefit of disambiguation grows with the corpus. In a small corpus the compression doesn't pay back the cost of the complex language. In a large enough one, it might. That's a clean, falsifiable hypothesis, and it's still untested. It's also the only Ithkuil claim I'm keeping. The language was never the point.

A name fixes a pattern

The name doesn't create the pattern. It fixes it: makes it stable, shareable, retrievable. Without a name the pattern exists and slips away. I'd push it further. Take a wine taster. The taster tells wines apart precisely because the articulations are clear in his head: green pepper, raspberry, cedar, relations to other fruits, other foods, wood. He's composing from named anchors. There's no single word for a wine with green pepper, cedar and raspberry. But there could be, and if there were, that pattern would be clearer still than the list. Composing and having a word are nearly the same thing. What the single word adds is that the concept becomes a block. You can refer to it, compare it, build on it, without reloading the description every time.

Programming makes this exact. A super-specific programming language is just binary. No ambiguity at all, and useless for thinking. A high-level language has to compile down to that same binary, so you never lose specificity. What you gain is concepts: a function, a type, a class. Abstractions are patterns too, higher-level patterns, and they have names. That's my point. They're patterns that were discovered and named, and once named they can be manipulated, compared, articulated, related. It's new intelligence, and no specificity is lost.

Naming the latent

Now the part I was actually reaching for. When you train a model, inside all those billions of parameters there are concepts that aren't explicit in any language but are necessary to encode human intelligence. Interpretability work already finds them: features that correspond to real concepts with no human label, extracted at scale from the model's activations. If those patterns were named, they'd be disambiguated and specified. You'd stop spending capacity on ambiguous subtleties. You'd compress large concepts into blocks. And you'd have a meta-language in which those blocks can be manipulated and related to each other, so you can keep discovering larger, more useful patterns. That's what an intelligence gain looks like to me.

This is the reverse of Ithkuil. Ithkuil is a prefabricated answer: someone decided in advance which distinctions matter. Here the patterns emerge from the model first, and get named afterwards. The extraction step already exists. The missing step is feeding the vocabulary back, so the system builds on it.

Here's the honest doubt, and it's the one that came closest to breaking the argument. Does naming add capacity, or only access? The model may already compose those latent features internally without a token for them. What's certain is that a named abstraction becomes explicitly manipulable, composable and verifiable, which is enormous for us, and lets the model reason in steps over blocks instead of rebuilding them each time. My bet is capacity, and I'm making it on the human precedent. In us, the named unit is exactly what allowed the next level. Algebra came after arithmetic had names.

A small experiment

This is testable at low scale, and I think a programming language is the perfect place to test it. Even a synthetic one. Write high-level programs in a language that doesn't exist anywhere, with functions, conditionals, loops, maybe objects. Compile them to something low level and train only on that output. The high-level patterns are still there, implicitly, dismantled into pushes and jumps. Keep the source. Then ask whether the model rediscovers those constructs, name them, and see whether you end up with a high-level language that encodes patterns already implicit in the original corpus.

The design has what a toy world lacks: perfect ground truth, generable at scale, and a free validation step. If the names the model earns line up with the constructs the compiler knew about, the discover-and-name step works, before you ever test the feedback loop. The invented language matters: constructs absent from every public corpus can't be recognized, only rediscovered. We have to be very careful which patterns to choose, and we don't have to automate everything. An AI model can help name. The pattern can't be a single opcode, or the feature is just lexical. Start with a conditional as the near-trivial control and a function call as the real test, since it demands stack discipline across distance. Then the naming has a grammar: a tag over a span, a macro with arguments that replaces the span, a definition that can be referenced and composed. Feed the names back into the corpus, retrain, and measure on combinations never seen. Recursion is the perfect test. No training program contains a function that calls itself.

Three models of equal size settle it. One trains on the annotated corpus. One trains on the plain low-level corpus. One trains on the plain corpus with random tokens inserted at the same rate, which separates "any extra structure" from "the right structure". Then measure: held-out loss, compositional generalization on programs that combine two constructs never seen together, the smallest model that reaches a target score, and whether new features appear over the named tokens, such as an idiom built from several constructs. Success looks like this: the discovered features line up with the original constructs, the annotated model beats the plain one at equal size and the random one doesn't, and a second round surfaces higher-order patterns the first could not.

What I haven't settled

Some questions survived every round:

1. Does naming a latent feature add capacity to the model, or only access for us?
2. Is naming the real bottleneck at all, if the model already composes those features without a token?
3. Which patterns deserve names, and what about the consistent features that match no known construct? Those are the interesting ones, and they have no ground truth.
4. Does a gain in a programming domain transfer to natural language?
5. Does the morphology problem come back once the corpus is full of new names: near-unique tokens, thin statistics?
6. Will the discovered vocabulary be legible to humans, or only to the model?
7. And the one I left behind: does a precise language pay for itself at scale?