Ubiquitous Language Was a Nice-to-Have. Agents Made It a Requirement.

It was date night, and I'd packed the evening—a few stops, a plan, the works. "Going shopping" was one quick item on that list: in, grab the thing, out. My wife heard "shopping" and pictured the good version—walk the aisles, take our time, make an evening of it. So we hit the store, I grabbed the one thing and said "let's go," and she was rightly irked. Same two words, two completely different plans. And I'm the kind of person who'd put "shopping: 15 min" on a calendar, so the misfire was mostly on me.

Here's what stuck with me. My wife and I have years of shared context—the biggest "context window" two people can build—and we still talk past each other. If two people who finish each other's sentences fumble one word, what chance does a model have, walking into your codebase cold?

That kind of fuzzy terminology rarely surfaces as a clean "wait, what did you mean?"—it festers. Leadership hears "staging is broken" or "we don't have good metrics," everyone nods, and three people walk away meaning three different things for months. What saved us was never low stakes; it's grace. Humans ask, forgive, and laugh about it later. Agents don't ask and don't forgive. They guess and ship.

Eric Evans named the fix more than twenty years ago, in 2003's Domain-Driven Design. He called it ubiquitous language: one shared vocabulary a team uses the same way across code, docs, and conversation. The idea was always sound and the tax was always real. What changed is who pays it.

Lately a lot of people have noticed—"ubiquitous language for agents" is having a moment. I'm not here to claim the idea; I'm here because I watched it break a team, and watched the fix work, a decade before the agents showed up. The pattern is old. The audience reading your words literally is new.

Agents don't ask. They proceed.

When a human hits an ambiguous word, they ask a follow-up. When an agent hits one, it picks an interpretation and keeps going—confident, fast, reporting success the whole way. A person who guesses wrong gets caught in the next conversation. An agent can run a week down the wrong road before anyone notices, with the bad reading baked into everything it touched.

The feedback loop that used to catch these problems ran through a person. Agents route around that person—Copilot, Claude, your internal automation turn your words into code without the "wait, which staging?" step. The ambiguity doesn't get caught. It gets executed.

Three patterns worth auditing

Most teams have these, and most have stopped seeing them. If you want to know where an agent will trip, look for:

Same word, different meanings. "Staging" might mean shared staging, your personal stack, or just "wherever I test things." A new hire reads "deploy to staging" and guesses; so does the agent. I've been on the wrong end of this: I came from Zept, where "observables" meant RxJS streams, then joined a team where "observability" meant metrics and telemetry. Same root, different worlds—and I said something confidently wrong in a meeting before it clicked.

Inverted words. Somewhere a team decided "dev" means the most stable pre-production environment—the opposite of the rest of the industry. Now every vendor doc and Stack Overflow answer means the reverse of what your team means. A human learns to flip it. An agent reads the most common definition across the whole corpus of human writing, and the majority wins—even though your team is the minority that matters here.

Overloaded words. One word covers a CLI tool, a local mode, and a remote service. Any single sentence is fine. But a thread about "the tool acting up" could be three unrelated problems, and nothing in the words tells you which.

That's the diagnostic. Same, inverted, overloaded. Run it against your own glossary and you'll find the landmines in about twenty minutes.

Those patterns detonate in three places. In prompts—"deploy this to staging" is a coin flip when "staging" maps to three things. In docs the agent pulls as context—one concept under three names across the wiki, the runbook, and Slack, retrieved together and stitched into a confident, wrong answer. And in cross-system automation, where a workflow chains steps with no human mid-chain to catch that "ephemeral environment" meant a different system two steps ago.

The uncomfortable part: your AI isn't hallucinating—your data is gaslighting it. A lot of what we call hallucination isn't the model inventing things. It's the model faithfully repeating the three contradictory things your team already wrote down.

This isn't a fringe failure mode. IBM pinned 72% of enterprise AI failures on inadequate context, not weak models—and vocabulary is the cheapest, most controllable slice of that context. You can't fix stale data or missing docs by Friday. You can decide what your words mean. When researchers handed a model a structured map of a domain's terms, its question-answering accuracy more than quadrupled—and a glossary is just the cheap version of that move.

And no, a smarter model doesn't save you. Ambiguity isn't a property of the model—it's a property of communication. There's an old joke: how do you tell a chemist from an electrician? Ask them to pronounce "unionized." The chemist says un-ionized—no charge left. The electrician says unionized—joined the union. Same letters, two unrelated words, and the only thing that tells them apart is a sound the model never hears. A better model just reads your contradictions more fluently—it still has to pick.

I've watched the fix work

At Shopify I worked on the experimentation platform, and adoption was bad. Data scientists, engineers, and PMs were all frustrated with each other, and the easy story was "the tool needs work."

The actual problem was words. "Experiment" meant a rigorous statistical trial to a data scientist, a feature flag with metrics to an engineer, and "proof my idea works" to a PM. Same word, three meanings, three groups quietly convinced the other two were being difficult. Nobody was wrong. They just weren't speaking the same language.

We didn't fix it with a wiki page nobody reads. We built the vocabulary into the tool—shared definitions, inline help right where the decision happened, a wizard that walked each role through the same terms. Experiment volume went up 80% in three months, and three times as many teams started using the platform. The technology barely changed. The words did.

And that was humans—who at least eventually argued it out. An agent never argues. It just confidently does the wrong thing and moves on.

The reframe

A model walks into your codebase with a sliver of context—whatever fits in the window—and reconstructs what your words mean from scratch, every time. A dictionary of your terms hands it that meaning on demand: the right definition gets pulled into the window exactly when the term shows up, instead of the model guessing from whatever it scraped off the internet. You're not writing docs. You're lazy-loading meaning into the context window, one term at a time, right when it's needed.

Every ambiguous term is a spot where an agent can silently pick wrong—and tightening your vocabulary is the cheapest hallucination reduction you can buy. No fine-tuning, no new model, no re-plumbing how your agents fetch context.

The fix isn't mandating vocabulary—people say what they say, and a rulebook nobody opens helps no one. It's a shared, living reference the whole team feeds, where "we use this word two ways" is something to surface, not hide. I'm building one now on a new project, and the feedback runs both ways: I'm learning where teams use the same word differently, and catching my own assumptions that were wrong. You don't standardize everything—just the words that matter—and flag the risky ones. A term marked "often mistaken" gets pulled up for clarification, and that hint is exactly what you wire into your agents. The new hire learns the real definitions in week one instead of reconstructing them over a quarter.

And the new hire isn't always a person anymore. Sometimes it's an agent reading your docs at three in the morning, with nobody around to ask "wait, which staging?"—and it will believe every inconsistent thing you ever wrote. Humans paid the ambiguity tax in slow conversations. Agents pay it in confidently wrong code. A glossary just became the cheapest way to stop paying it twice.