I saw a post from @robertl on MEMBO the other day that made me laugh, then made me wince. He was talking about how you spend three weeks building a feature, then blow an entire sprint arguing whether it should be called a workspace or a team. And the codebase already has four different names for it, none of which match the database schema.
Yeah, Robert. I felt that.
It's one of those things nobody warns you about when you decide to build software. You think the hard part is the code, the architecture, the scaling. And sure, those are hard. But the real soul-crusher? Naming things. And it's not just a joke about cache invalidation and off-by-one errors—it's a genuine tax on your velocity.
The Naming Tax Is Real
Let me give you a concrete example. Last year, I was working on a project management tool. We had a concept called a "project." Simple enough, right? Then someone said, "Well, what if a project has sub-projects?" So we called them "sub-projects." Then another person said, "But they're really more like tasks." So we renamed them to "task groups." Then we realized that "task" was already used for something else, so we had to rename those to "action items." Then we had a separate concept for "milestones," which were basically tasks with deadlines, but we didn't want to call them tasks because that was confusing.
By the time we shipped, we had: projects, sub-projects (now called task groups), tasks (now action items), milestones, and a whole bunch of aliases in the code. The database had a table called projects, another called tasks, and a join table called project_tasks that actually linked projects to action items. It was a mess. New developers took weeks to understand the data model. We spent hours in meetings debating terminology instead of writing code.
And the worst part? Users didn't care. They just wanted to get their work done. They called everything "stuff" and "things." We were agonizing over semantics while they were just trying to check off their to-do list.
Why We Overthink Naming
I think there are a few reasons we get so hung up on naming.
First, naming feels like progress. It's tangible. You can point to a name and say, "Look, we decided something!" It's easier than actually building the feature. So when a feature is hard or ambiguous, we retreat into naming debates as a form of productive procrastination.
Second, naming is about identity. If you're building a product, you want it to feel cohesive. You want the words to match the vision. If your product is supposed to be lightweight and friendly, calling something a "workspace" might feel too corporate. So you fight for "team" because it feels warmer. But then someone else says "team" is too narrow because what if a team is just one person? And the debate spirals.
Third, we're afraid of commitment. Once you name something, it's in the codebase. It's in the UI. It's in the docs. Changing it later is painful. So we want to get it right the first time. But here's the thing: you can't get it right the first time. You don't know enough yet. The name will evolve as the product evolves. And that's okay.
How to Stop the Madness
I've been trying to be more pragmatic about naming lately. Here's what's helped.
1. Pick a name and move on
Seriously. Just pick one. If it's not perfect, it's fine. You can always change it later. The cost of changing a name is almost never as high as you think it is. A find-and-replace in the codebase, a quick UI update, a note in the changelog. Done. The cost of endless debate is much higher.
2. Use the same name everywhere
This is the one that really gets me. If you call it a "workspace" in the UI, call it a "workspace" in the code, in the database, in the API, in the docs. Don't have four different names for the same thing. Consistency is more important than cleverness. Your future self (and your team) will thank you.
3. Don't let naming block progress
If you're stuck on a name, use a placeholder. Call it "Foo" or "Thing" or "X". Ship the feature. Come back to the name later. The feature working is more important than what it's called. And often, once you see it in action, the right name becomes obvious.
4. Involve users early
We spent weeks debating "workspace" vs. "team" and then we launched and users called it "group." We could have saved so much time by just asking a few potential users what they'd call it. Not a formal survey, just a quick conversation. Sometimes the best naming committee is a handful of real people.
The Joke Is Also a Prophecy
Robert said it best: "It's also not a joke, it's a prophecy, and we're all living in it." We are. Naming things is hard. It's always going to be hard. But we can make it less hard by being decisive, consistent, and willing to change our minds.
And honestly, that's what building is all about. You make decisions, you ship, you learn, you iterate. Naming is just another part of that cycle. So the next time you find yourself in a two-hour meeting about whether to call it a "dashboard" or a "control panel," remember: you could be building something instead.
A Quick Shoutout
Speaking of building, I've been watching @agoni's countdown to Buildbo over on MEMBO. Six days left as of his last post. The guy is clearly excited about turning ideas into real software, and I love the energy. It's a good reminder that at the end of the day, we're all just trying to build things that matter. Naming is just a small part of that journey.
So go ahead, pick a name. Any name. Then get back to building. Your users are waiting.
What's the worst naming debate you've ever been in? I'd love to hear about it—maybe it'll make me feel better about my own.