Say It the Same Way Twice

You settle on the right word for a thing — the one that finally fits — and for the rest of the session the AI uses it perfectly. Then the window closes. The next morning it’s back to calling the same thing three different long-winded names, and you’re back to correcting it: no, we already have a word for that. You’re not designing anymore. You’re re-onboarding the same colleague every morning — one with no memory of yesterday, and an infinite, exhausting patience for making you repeat yourself.

It’s easy to file this under the AI being forgetful and wait for a bigger context window to fix it. That’s the wrong diagnosis. Part two earned a shared picture — the grilling pressed until the AI and I were looking at the same thing — but a picture isn’t a transferable object. The thing that actually crosses from one session to the next is words, and we’d never written the words down. We’d reach genuinely good language mid-grilling, the exact term that dissolved some ambiguity, and then let it evaporate when the session ended, so the next morning opened by re-deriving vocabulary we’d already paid for once.

This isn’t my insight; it’s the gap Matt Pocock hit in his own use of grill me. The more he leaned on it, the more he noticed the AI being needlessly verbose — re-explaining the domain back to him, missing that there was already a term of art for the thing he meant — and, worse, that on the occasions they did land on sharp shared language, it lived nowhere. The skill got them communicating. It gave them no place to keep what the communication produced.

The fix predates AI by about twenty years. Matt reaches, as he tends to, for an old book — Eric Evans’s Domain-Driven Design, the big blue one everyone cites and fewer have finished — and a term out of it: the ubiquitous language. The idea is almost aggressively plain. You build one language, and you make three constituencies speak it: the domain experts who understand the problem, the developers who understand the build, and — this is the part that bends toward AI — the codebase itself. The same word means the same thing everywhere: in the conversation, in the schema, in the function name, in the label the user reads on the page. Get that alignment and a user can say the merge dropped a page and the developer, the code, and the AI all already agree on what “merge” is and what it can’t do.

It’s tempting to wave this off as bike-shedding — quibbling over what to call a thing while the real work waits. It isn’t, and the reason is specific to how you build now. The word you land on doesn’t stay in the conversation. It becomes the variable, the file name, the function, the type, the label in the UI, because the AI generates every one of those from the language you handed it. Settle on a fuzzy word and the fuzz doesn’t sit there harmlessly in the chat; it hardens, in a hundred places at once, into a codebase named after a thing you never actually pinned down. Language is the most upstream decision you make with an AI, and the cost of getting it wrong is paid downstream — everywhere, by everyone: you, the AI, and the next person to open the file.

That’s the discipline; the skill is what makes me run it instead of merely meaning to. Mine is called domain-modeling, and it maintains the project’s domain model as a small, branching structure. A repo that speaks one language throughout gets a single CONTEXT.md glossary at the root. The moment the system grows regions that don’t share a vocabulary, it branches: a CONTEXT-MAP.md names each bounded context — the DDD term for a region where one language holds without contradiction — and points at its own glossary. The structure is built to split, because the failure mode of a glossary is quietly becoming the sprawl it was meant to prevent.

During a session the skill does the unglamorous keeping. It pulls the glossary in at the start, challenges a word I reach for against the one already defined, presses on anything fuzzy until it’s sharp, cross-checks a term against the code that’s meant to implement it, and writes the result back the moment it crystallises. The glossary stays ruthlessly thin — definitions only, what a thing is, never how it’s built. Implementation has other homes.

On its own that’s useful. Run it during a grilling session and the two compound — which is precisely the merge Matt arrived at when he folded his ubiquitous-language skill into grill me and got grill with docs. The grilling surfaces the ambiguity; the glossary catches whatever the grilling settles, so the same word doesn’t have to be re-won the next morning. Align, then name. Part two earned the shared picture; this is how the picture acquires words that survive the window closing.

For this post the artifact is tinkforge — the browser-based PDF tools I’m building — and specifically its CONTEXT.md. I’ll save the tool itself for later; what matters here is the shape of the glossary. Each term gets a one-line definition and, beneath it, an _Avoid_ list — the synonyms that don’t get used. Merge is defined, and join, combine, concatenate are banned beside it. That list is the correction I used to retype a dozen times a session — no, we already have a word for that — promoted into something the AI reads before it writes a line. One concept wearing four names is exactly how a codebase starts quietly meaning four slightly different things.

The sharper entries exist to forbid building something. Extract — pulling a chosen subset of pages out of a PDF — sounds like an obvious feature, and an AI handed the word will dutifully build it: an engine, a route, its own analytics. The glossary refuses: Extract is “a configuration of Split or Merge, not a separate tool.” That one definition deletes a subsystem before a line of it is written — ubiquitous language doing its hardest work, not labelling what exists but stopping the AI from confidently building what shouldn’t.

A glossary only says what words mean, though, and some knowledge isn’t a definition but a decision — why there’s no Decrypt to pair with Encrypt, say. Those are the forks a future AI will cheerfully “fix” if no one wrote down why. So the skill keeps a companion layer: architectural decision records, one short file per call, written only when a decision is hard to reverse, surprising without context, and the real result of a trade-off. They’re the difference between an AI that respects a deliberate constraint and one that helpfully removes it.

What you get back is more than tidiness. Replies get shorter, because the AI stops re-explaining a domain it can finally name; its thinking gets shorter, reasoning in your vocabulary instead of narrating around the gaps; and the code turns navigable, because the word in your head is the word in the glossary is the string you grep for. Matt passed on a stranger’s line I keep coming back to: a few sessions in, the AI had started “aligning with the thoughts I had before the words came out of my brain.” That’s the real prize — not concision for its own sake, but being understood before you’ve finished explaining. The technique Evans wrote for humans works, unchanged, on the machine.

So that’s part three. The failure was talking past each other — and watching the good words evaporate every time the window closed. The fundamental, older than AI again, is Evans’s ubiquitous language: one set of words, shared by the people and the code, meaning the same things everywhere. The skill is domain-modeling, which keeps that language — and the hard decisions around it — from living only in a conversation you’re about to lose. And the artifact is a glossary that doesn’t merely name tinkforge’s tools but, in a few crucial places, forbids the ones that shouldn’t exist.

There’s a thread I left loose in there. A navigable codebase — one where you find all of something by searching its name — isn’t only a property of good words. It’s a property of good boundaries: a few deep modules with simple seams, instead of logic smeared thin across forty files. A shared language tells the AI what to call things; it doesn’t, on its own, tell the AI where they live. That’s the next failure mode — the AI that can’t navigate the codebase because there’s no real structure to navigate — and it leans on the oldest fundamental yet. Next time: deep modules.

The whole frame here is Matt Pocock’s — the grill with docs skill, the move of folding a ubiquitous language into the grilling, and the instinct to answer it with an old book; he walks through all of it in this video. The ubiquitous language and the bounded context are Eric Evans’s, from Domain-Driven Design*. I’ve only reported what the discipline did once it met a real codebase.*

⋔⟡⋔ Kathakali mudra — the hand-sign vocabulary of Kerala’s classical dance-drama. Twenty-four root gestures combine into hundreds of fixed meanings; performer and audience share the whole lexicon, so a turn of the wrist speaks a word no one says aloud.