In 1987, a man named Steve Wilhism invented the Graphics Interchange Format at CompuServe. He wrote the code that made it possible to send animated pictures through email. When CompuServe shipped it, they said “CompuServe made this.” They didn’t put his name on any press release.

Fifteen years later, someone would need a word for Wilhism’s invention. Nobody called it “the CS graphics thing from 87.” They called it the GIF, pronounced with a soft G, debated in forums that would never resolve how to pronounce what Wilhism made. He kept his mouth shut about it until an oral history project asked him directly: should it be JIF or GIF? He answered with something most people have opinions on now without knowing the answer was asked by a living person who sat at a desk and wrote code for it.

The story is worth telling because it reveals something about how our relationship to invention changed between 1987 and the year you last installed an app on your phone. Back then, there was always a name attached to what was made. Bjarne Stroustrup built C++. Linus Torvalds built Git. Tim Berners-Lee built the web. These names show up in keynote slides and building plaques with honest-to-god gratitude. The inventor is the story.

I don’t think this happened by accident, but I’m also not sure exactly what caused it. What I do see clearly is that around the turn of the millennium, invention became less about writing clever code from scratch and more about arranging things that already existed into a shape that worked. The invention shifted from implementation to composition.

This matters because naming things is how we build lineage. When you can point to a person, you can trace decisions. You understand why something was built the way it was by talking to the person who made it. But when the “inventor” is listed as a corporation or an open-source project, that lineage gets fuzzy fast. You can’t call a company up and ask why they made the choice they made. They’ll send you a press release written by a PR firm.

Here’s what I think is the quiet cost of losing people from these stories: it becomes harder to hold design decisions accountable when nobody remembers who was sitting in the room. Linus Torvalds still answers your email. He has opinions about merge strategies and tree management. That’s useful information. But how do you hold a brand responsible for its own technical choices? You can’t interview Apple Engineering.

I’m guilty of this pattern too, by the way. I’ve written about ADRs as a tool for capturing decisions, but ADRs assume that the person who made the decision still exists in the organization to explain it. What happens when you build a system on top of something invented by someone who left five years ago, whose name was never recorded anywhere?

The answer is that you stop knowing. You accept the interface and stop questioning the implementation, which starts as practical wisdom and becomes intellectual laziness. The GIF story is just one example, but the pattern appears everywhere: JavaScript frameworks where the creators are unrecognizable beneath layers of corporate branding, networking protocols designed by people whose work has been rebranded into nothingness, APIs built by engineers who don’t get their names on the dashboard that depends on them.

The thing I keep coming back to is this: it’s not just about credit. It’s about whether we can actually understand our tools well enough to use them well. A name is a handle. If you’ve lost the handle, you’ve lost part of the story — the ability to trace why something works the way it does back to someone who could explain it in a conversation rather than a docstring.

Maybe this is just how technology matures. When something becomes useful enough, it stops belonging to the person who invented it and starts belonging to everyone who uses it. The name gets replaced by the brand because the product outgrows the people who built it. That’s not necessarily bad. It’s what happens when a tool becomes infrastructure.

But the cost is real. We trade traceability for adoption, and we don’t talk about that trade very often. The people were always there — Wilhism wrote the GIF code, Stroustrup wrote C++, Torvalds pushed the first Git commit — but somewhere along the way, we decided the story matters less than the product. Maybe it does, in a world where billions of users can’t read an oral history transcript. But we should at least pretend to believe that the people mattered before deciding they didn’t.

I’ve always found it useful to keep asking who actually built what we use. It turns out most answers involve names instead of logos, and that makes all the difference when you need to understand why something works the way it does. Some names stick. Most don’t. I write this one down because someone should have remembered Steve Wilhism’s name.