Tags vs Folders: A Better Way to Organize References

Every reference library eventually hits the same wall. You save a screenshot of a checkout flow with a beautiful empty state and a great green button — and then you have to decide: does it go in ecommerce, forms, empty-states, or buttons? Pick one folder and you’ll never guess the same way in six months. Pick none and it rots in Downloads.

This is not a discipline problem. It’s a structural one. And it’s the single biggest reason folders fail for visual work.

The world isn’t a hierarchy

Folders assume every item has exactly one correct home, arranged in a neat tree. But the things we collect — references, ideas, inspiration — are a network, not a hierarchy. As Karl Voit puts it in his essay on tagging:

Everybody who tries to put “the world” into a strict hierarchy will fail.

A single image is genuinely about several things at once. It’s a fintech app and a dark-mode UI and a data-dense dashboard and “that layout I liked.” A folder makes you amputate all but one of those facts. A tag lets the image keep all of them.

That’s the whole case in one line: a file lives in one folder, but it can carry many tags. When the thing you’re organizing belongs to more than one category — which visual references almost always do — folders can’t represent reality and tags can.

What you’re actually optimizing for: finding things again

It’s easy to treat organizing as the goal. It isn’t. The goal is retrieval — future-you, mid-project, pulling up the right reference in seconds. Voit again:

Information retrieval is the main reason why we do apply tags in the first place. Never forget that in this context.

This reframes everything. You don’t tag to build a beautiful taxonomy. You tag so that when you think “that pricing page with the toggle,” you can actually find it. The test of a system isn’t how tidy it looks — it’s how fast it answers a question you’ll have later. Folders optimize for filing. Tags optimize for finding. For a reference library, finding is the entire job.

“Just let AI organize it” isn’t the answer either

The fashionable counter-position — mymind’s “the folder is dead, don’t organize at all, let AI sort it” — gets the diagnosis right and the cure wrong. Folders are a bad fit. But handing all structure to an algorithm trades one problem for another: you lose the ability to retrieve things on your terms, in your language, and you can’t see why something surfaced or didn’t.

There’s a reason your own tags beat a machine’s. Voit’s point about personal vocabulary holds: you’re far more likely to remember the words you chose than terms some predetermined system assigned. The sweet spot isn’t “no organizing” and it isn’t “manually file everything into a tree.” It’s a small, intentional set of tags you control, plus good search. Light enough to keep up with, structured enough to trust.

How to build a tag system that doesn’t sprawl

The honest catch with tags is that without rules they metastasize — you end up with ui, UIs, ui-design, and interface all meaning the same thing, and the whole point (retrieval) quietly dies. The fix is a handful of conventions. These are lightly adapted from Voit’s tagging rules, and they work just as well for visual references as for notes:

  • Use as few tags as possible. Two to four per item is plenty. More feels thorough but actually dilutes search.
  • Limit yourself to a defined set. Decide your vocabulary up front and reuse it. A tag you invent once and never reuse is noise.
  • Don’t let tags overlap. If buttons and cta mean the same thing to you, keep one and kill the other.
  • Keep tags general. Tag the kind of thing (empty-state, pricing, dark-mode), not hyper-specific one-offs. General tags get reused; specific ones don’t.
  • Stay consistent: lowercase, plural, single words. buttons, not Button or nice buttons. Consistency is what makes search reliable.
  • Omit the obvious. If your whole library is design references, design tells you nothing. Tag what distinguishes an item, not what it shares with everything else.

A practical starting taxonomy for a design reference library might be: a few patterns (onboarding, pricing, empty-state, settings), a few attributes (dark-mode, data-dense, playful, minimal), and a few sources or projects (linear, client-x). That’s a dozen tags that will carry thousands of images.

Collect wide, tag tight

One more habit makes the whole thing work: separate capturing from sorting. The best reading and collecting strategy is a wide funnel and a tight filter — be willing to save anything that looks even a little interesting, then be ruthless about what you keep and how you label it. Capture in one tap so you never lose a reference to friction; tag in a quick weekly pass so the library stays trustworthy.

And resist hoarding. A reference library you never revisit isn’t an asset, it’s a landfill. The point isn’t to save everything — it’s to keep the few things you’ll actually reach for, tagged well enough to find.

Where this lands

Folders break because inspiration is cross-cutting. Pure AI sorting breaks because you lose control of retrieval. A small set of intentional tags, plus search, is the durable middle — and it’s exactly the model Kelu is built on: many tags per item, search that finds them, synced across your iPhone, Mac, and the web so the same library is everywhere you are.

If you’re starting from a pile, the next read is how to organize design references — the same system in practice: think of a thing, find it in ten seconds, from any device.