Why Most AI Tools End Up in Your Bookmarks

Your bookmarks folder is a graveyard.

Go look. Right now. There's an AI tool in there you saved six months ago because it was going to change how you work. There's a GitHub repo you starred at 1am along with forty thousand other people. There's a demo video you sent to a friend with the caption "insane." There's a tab group you named try this weekend, in a weekend that has since passed about twenty-four times.

You never used any of it.

And notice something: you don't feel bad about the ones you forgot. You feel bad about the ones you remember. The tool you know is good. The tool you know would help. The one you actually opened, read the setup instructions for, and quietly closed.

That isn't laziness.

That's a product problem, and right now it's the biggest one in AI. AI tools are everywhere, but actually using them is still harder than it should be.

Discovery stopped being the hard part

Finding AI tools used to be the hard part. You had to know which corner of the internet to lurk in.

Now it's impossible to avoid them. They're in your feed, your group chat, your inbox, in directories that list thousands of them, in launch posts that arrive faster than anyone can read. Something remarkable seems to ship every day.

Discovery is solved. Solved so completely that it turned into noise.

So here's the uncomfortable question. If you have access to more AI capability than ever before, why does your Tuesday look exactly like it did last year?

The distance between "this is amazing" and "this is mine"

Watch what actually happens when you try to use one of the things you saved.

You find the repo. You clone it. The README assumes Python 3.11 and you have 3.9. You fix that. Now you need the dependencies, and one of them wants a compiler you don't have. You fix that. Now there's a .env.example with six variables in it. Three are API keys. Each key lives behind a different signup, and two of them want a credit card before they'll hand one over. You get the keys. You run it. Port 3000 is already in use. You fix that.

It runs.

It runs on your laptop, in a terminal window, and only while that window stays open.

To actually use this thing in your life, you'd have to deploy it somewhere. That's a different pile of problems, and by now it's 11pm on a Tuesday.

So you close the terminal. And the tool goes back to being a bookmark.

Every one of those steps is small. That's exactly why it's easy to miss what they add up to: a wall.

The tax nobody counts

The AI industry measures capability obsessively. Benchmarks, evals, context windows, parameter counts, leaderboards that shuffle weekly.

Almost nobody measures the distance between I want this and this is working for me.

For normal people, that distance is the only number that matters.

There are vastly more AI tools available to you than there were three years ago. Is your week correspondingly easier? For most people the honest answer is no, and it isn't because the tools are bad. The tools are extraordinary. The problem is that capability sitting behind a setup process is capability you don't actually have.

A tool you can't run isn't a tool. It's a rumor.

The reframe

We don't have an AI discovery problem anymore. We have an AI usability problem.

Those call for completely different work. A discovery problem is solved by helping people find things. A usability problem is solved by shortening the distance between finding and using.

Yet a surprising amount of the ecosystem still optimizes for discovery: more directories, more roundups, more launch feeds, more things to save. So the gap between discovering AI and actually using AI keeps getting wider. Every week adds more things to find. The number of things to discover is growing faster than the number that feel effortless to use.

Which is why every "top 50 AI tools" roundup feels productive to read and changes nothing about your life. It's a discovery solution to a usability problem. You end up with a longer list of things you're not using.

What usability actually means here

It doesn't mean a prettier interface or a nicer onboarding tour. It means passing three tests that most AI tools fail:

1. Can you get value from it without reading instructions written for someone else? Many setup docs are still written by builders, for builders. The moment a tool assumes you know what a virtual environment is, it has quietly chosen its audience.

2. Does it survive first contact? There's a canyon between "runs in a demo, on the maker's machine, with clean example data" and "runs on your machine, with your messy real inputs, on a day when you're busy."

3. Is it still there tomorrow? A tool that exists only while a terminal window is open never becomes part of how you work. It was an experiment, not an upgrade.

Fail all three and it stops mattering how good the underlying model is.

Who is actually paying for this

Not developers. Developers are fine. For them a repo is a five-minute errand, and setup friction is background noise they stopped hearing years ago.

The people locked out are the ones with the best sense of what should be built.

The operations manager who knows precisely which weekly report burns six hours and should not exist. The teacher who could describe the perfect grading assistant in one paragraph. The clinic owner who understands their scheduling mess better than any engineer ever will.

All the domain knowledge. Zero tolerance for debugging an environment at 11pm.

We've built an ecosystem where your ability to solve a problem with AI depends on your willingness to configure software. Those are unrelated skills. Somehow we made the second one a prerequisite for the first.

That's the whole thing, in one sentence.

The takeaway

One of the next big unlocks in AI won't come only from smarter models. It will come from making the capability we already have dramatically easier to reach. Models are already far ahead of what most people can actually reach.

The next breakthrough won't only be about what AI can do. It'll be about how easily the rest of us can actually use it.

It'll be closing the gap between discovering AI and actually using AI. Between the bookmark and the outcome.

Go open that folder again. Every item in it is a small piece of evidence for the same claim: the bottleneck was never the intelligence.

That's the problem we couldn't stop thinking about. It's why we kept iterating on Taku.

But users weren't the only ones stuck.

As building became easier, we started noticing another problem on the other side: people could create more than ever, and still struggle to get anything they built in front of the people who needed it.

That's tomorrow's story.