Twenty-nine characters. That’s how long a string like gemini-2.5-flash-lite-preview runs when you type it into a config file, and I have typed variations of it enough times to have opinions. Not one of those characters tells me what the model is good at, how much it costs, or whether it will still resolve next quarter. It’s a license plate pretending to be a name.
So when TechCrunch ran a piece arguing that Google’s Gemini has a branding problem, and that the rest of AI does too, the story got picked up fast, Yahoo Tech and Bitcoin World among others. That kind of pickup usually means the piece named something people already felt. I felt it. I’ve felt it every time a client asks which model their bot is running on and I have to answer with a hyphenated serial number and a shrug.
Branding confusion is a build problem, not a marketing problem
It’s tempting to file this under marketing gripes. Somebody in a brand meeting picked a bad word, the logo is fine, move on. But naming is load-bearing infrastructure when you build bots for a living.
Here’s what unclear model naming actually costs me on a normal week:
- Routing logic that reads like guesswork. If the name doesn’t encode capability, I have to maintain a separate map from model ID to “what this thing is for,” and that map rots.
- Documentation that ages badly. Write a tutorial referencing a specific model string, and you’re signing up to revise it on someone else’s schedule.
- Support conversations that go nowhere. A user says “your bot got worse.” Worse than what? Which version? Nobody remembers, because the version was never memorable.
- Cost surprises. When the naming scheme mixes tier, size, speed, and preview status into one dash-separated blob, it’s easy to point production at something priced differently than you assumed.
None of that is a branding inconvenience. It’s a source of real bugs and real invoices.
The whole space has the same disease
The reason the TechCrunch framing landed is that it isn’t only a Google issue. Every major lab has converged on the same pattern: a family name, a decimal, a speed adjective, sometimes a size, sometimes a date stamp, occasionally a word like “preview” or “experimental” that quietly means “we may remove this.” The result is a naming system that’s precise enough for a changelog and useless for a human conversation.
Compare it to how we name almost everything else in software. Version numbers work because there’s a shared contract behind them. You know roughly what a major bump implies. AI model names don’t carry that contract. A decimal bump might mean a different architecture, a different price, a different context window, or barely anything at all.
That last case is the interesting one. TechCrunch’s Pixel 11 Pro XL review carried the line that snappier cameras can’t hide an iterative upgrade, and the same tension runs through model naming. When the product is incremental, the name has to do more work. Naming inflation is what happens when the branding is asked to carry weight the release can’t.
Trust is downstream of names
There’s a second reason to care, and it showed up in another TechCrunch story the same week: Google is giving publishers a new way to fight AI-driven traffic losses. Whatever you think of that specific effort, it points at a real problem. AI systems are becoming intermediaries between people and the work of others, and intermediaries live or die on trust.
Trust needs a name you can hold onto. When someone reads an AI answer, or talks to a bot I built, they should be able to say what produced it in words that mean something. “A Gemini model, one of the fast ones, I think” is not a foundation for accountability. If we can’t name the thing, we can’t reason about it, cite it, compare it, or blame it.
What I do about it in my own stack
I can’t fix upstream naming, so I wrap it. A few habits that have saved me repeatedly:
- Define an internal alias layer. My code calls
FAST_CHATorDEEP_REASONER, never a raw vendor string. Swapping providers becomes a config change instead of a refactor. - Pin exact model IDs in production and log them with every response. When behavior shifts, I know precisely what changed.
- Treat anything labeled preview or experimental as temporary by default, with a fallback already wired in.
- Give users plain-language names. “Quick mode” and “Careful mode” beat a version string every time.
That alias layer is maybe forty lines of code and it’s the single highest-return abstraction in my toolkit. Not because it’s clever, but because it puts naming back under my control.
The labs will keep shipping models faster than they can name them well. Building a thin layer of your own vocabulary between their serial numbers and your users is the cheapest insurance available.
🕒 Published: