Question: Why did every solution that relied on a name eventually fail?

I thought names were good identifiers.

They weren't.

I didn't realize I was fixing the same bug three times.

Not because the bugs looked similar.

Because they didn't.

I was building a shared backend to connect a video editor and an analytics dashboard — two separate tools that needed to agree on what a "project" was. Every time I needed to answer a simple question — is this the same thing I saw before? — my first instinct was the same: check the name.

It felt obvious every time. It broke every time.

First time: the filename

The editor exported projects as downloadable JSON files. To reconnect exported projects to YouTube videos, I kept a lookup table based on filenames.

It looked obvious.

Until a title changed. Rename the file, and the lookup breaks — the system now thinks it's looking at a project it has never seen before.

I hadn't picked a fragile key.

I'd picked one that was designed to change.

Second time: the same filename, twice

Later, I needed a way to avoid registering the same project twice. The fix seemed simple: if a file with this name is already registered, reuse its ID instead of creating a new one.

That also broke — in a more embarrassing way. Two completely different projects, created independently, happened to share a title. The second one silently inherited the first one's identity. The system could no longer tell them apart.

Names change. Languages change. Identifiers don't.

Third time: "Favorites"

The last one was smaller, but it was the same shape. I needed to filter a legacy system-generated playlist out of a dropdown, so I checked whether its title was "Favorites".

That's an English label. The channel this system runs on publishes in Korean. The moment YouTube's UI locale changes, that title changes with it — and the filter silently stops working, with no error, no warning, just a stray playlist quietly showing up where it shouldn't.

The label wasn't the playlist.

It was just one possible way YouTube chose to display it.

Even the original filename-based lookup eventually disappeared entirely. Instead of trusting filenames, I started trusting the YouTube API itself — asking it directly which playlists were system-generated, instead of guessing from a label.

What I kept doing wrong

The interesting part wasn't that I fixed three bugs.

It was that they were actually the same bug.

Every one of them came from the same shortcut: reach for something a human already reads — a filename, a title — and let the system treat it as if it were permanent. Every one of them broke for the same reason: the human- readable version of something and its identity are not the same thing, and nothing forces them to stay in sync.

The fix was never a better filename.

Or a better title.

It was to stop trusting names altogether.

A name is for people.

An identity is for systems.

Sometimes the real work isn't fixing bugs.

It's realizing they all came from the same wrong assumption.

Wrong assumption: human-readable names (filenames, titles) are stable enough to use as identifiers Discovery: a name and an identity are different things — only one of them survives being renamed Next step: the second time this happened was the strangest one — two unrelated projects colliding under one name. That's its own story, coming next.