Learnings from building Kelp: Getting people the information they need when they need it is hard!
Reflections on pausing the contextual recommendation tool, Kelp, concluding that its goal—getting people the right information at the right time—is nearly impossible for a third-party app to achieve. The core problem is technical: without deep, OS-level access to user data and behavioral signals, recommendations remain mediocre. True contextual help must be built into the operating system itself. The key business takeaway was the need to solve a highly specific, paying use case for a narrow audience before attempting a broad, cross-platform solution.
I've decided to temporarily halt progress on Kelp and take a job. Why? And what did I learn?
My goal with Kelp was to build a tool that "gets people the information they need when they need it." That turned out to be much harder than I expected.
Recommendations are a multi-sided problem. Kelp needs three things:
- Access to the information to be recommended
- Signals for when to recommend it
- A UI for presenting the recommendation
For the first, you have to cross boundaries between native apps (Chrome, Safari, Messages) and API-driven tools (Gsuite, MS Teams). Even with modern APIs, there are gaps in the data — and those gaps leave you in an "uncanny valley" of mediocre recommendations.
At best, Kelp can combine "meh" information with "meh" signals into a fantastic UI.
Meh times meh is still meh.
For example, Kelp can't compete with Safari's recommendations that pull from Messages. Kelp has no access to links in Messages, and it can't surface recommendations across both mobile and desktop browsers on iOS.
For my users, Kelp was always missing some integration, or they had a workflow I hadn't handled. As a solo founder, I found myself iterating on integrations far more than on the core product.
What does the future hold?
I still believe there's space for a tool that provides contextual recommendations. We need less focus on helping people buy things they don't need and more on helping people be their best selves.
But with advertising dollars so close at hand, contextual recommendations haven't had "big tech" money thrown at them. There's no tool that actively helps us maintain relationships with friends (clay.earth is perhaps the closest), prepare for meetings, or find things by context instead of keywords (e.g., "what was that book Nicki sent me?").
I'm not sure what comes next, but I do want to reassess where Kelp should live (browser, desktop, or mobile) and how to package it as a product — including how much privacy should matter.
How might Kelp fit in with other tools?
Kelp doesn't exist in isolation. It's part of a broader ecosystem of "personal information management" tools, and looking at that space helps clarify where it might fit.
Like Kelp, these tools all suffer from the limitations of upstream APIs.
Digital personal assistants
Digital personal assistants have finally escaped the legacy of Clippy — only to run headfirst into the briar patch of call centers and support chatbots. As a result, consumer-facing assistants don't feel like an enjoyable, "premium" experience.
Some assistant startups targeted meeting scheduling (e.g., x.ai). Today we have Doodle, Calendly, and native calendar features that handle that messy transaction better. It turns out that's all we really needed.
What about voice assistants? Even with massive technological achievements, Alexa, Google Assistant, and Siri remain far behind the prickly assistant in the Knowledge Navigator demo.
Their core problem is that the UX for a digital assistant isn't clear or discoverable. A good product sets expectations and then meets — or exceeds — them. Assistants struggle to signal what they can actually do, so people use them for the handful of cases they stumble onto early and never go further (source).
I think the future of digital assistants is helping us navigate messy transactions. In healthcare, for instance, a chat UI is meaningfully less frustrating than trying to actually reach your PCP. Within that narrow scope, human-augmented chatbots are performing quite well for many digital health businesses.
The 'command line' for your life
There's a lot of hype in the "command line" space, but nothing has reached mainstream adoption. Many will remember Greplin; now we have Raycast and Searchable.ai. Similar concepts, different implementations.
My hypothesis is that, like voice UIs, a command line isn't discoverable. People explore a little when they first use the tool and rarely go deeper. So these will mostly serve the "optimizer" crowd — but that audience is growing and has purchasing power. Expert tools can be viable businesses today.
Still, I believe the optimal UI for most tasks is direct manipulation: accurate and immediate. Command lines trade directness for the efficiency of hotkeys, and for most people correctness and control matter more than speed.
End user programming
End user programming is the idea that people should be able to write small programs to handle simple, repetitive tasks. Apple and Google's smart home apps are probably its widest distribution — people set rules like turning off the lights when they leave the house.
This space faces a structural challenge: it's easier than ever to just learn to code. The set of people who have a problem programming could solve but don't want to learn to code is relatively small. "If this then that" has entered common parlance, but spreadsheets still dominate, and "no code" tools are evolving inside narrower verticals (like smart homes).
So there's no mass-adopted way to program behaviors across every app (Apple Shortcuts might be the closest) — and perhaps that's fine.
"Desktop 2.0" (or 3.0?)
The "networked thought" model popularized by Roam Research and Obsidian links information not by "app" or "folder" but by [keyword]. What if that extended to the entire desktop? Our files, web pages, and emails would all link together like in Roam or Obsidian — minus the [braces] and pound signs.
This might appeal to some users, but it leaves out most social interactions and any information that's passively rather than actively tagged.
My hypothesis is that the next iteration of the desktop will center on people instead of apps. That OS would extract data from apps (mobile) and files (desktop) through a global identity platform.
As Meta moves to capture more of people's time while routing around Apple's ad blockers, I expect this to become a major battleground over the next decade.
Summary: The future is contextual recommendations
I believe contextual recommendations need to be built seamlessly at the OS level to work — and as an independent developer, I don't have the leverage to make that happen.
What did I learn from a business perspective?
Find a small use case that people will pay for first.
I should have done more diligence to find specific customers with specific needs. My target — people managers and individual contributors at startups with too many meetings — was too broad. Everyone uses their own set of tools (Gsuite, Notion, MS Office), and teams share information differently.
I wanted to build a cross-tool solution, but there's real value in something narrower: "we make Google Docs more efficient" beats "we help you manage your team's information."
I also learned that it's nearly impossible to monetize Google Chrome extensions — I should have abandoned that approach sooner.
Last but not least: Open sourcing Kelp!
I hope it proves useful to future builders in this space. You can check it out on GitHub.
