Ask any Product or Marketing person and they’ll tell you: Everyone sucks at new feature discovery and adoption. Which is funny, since that’s basically the main job of a lot of later-stage product teams. Once you’ve found Product-Market Fit, you spend all of the time trying to expand it. More use cases, more features, more value for your existing customers. And hopefully more revenue, because that’s generally how capitalism works.
But there’s just one tiny problem. Nobody uses them damn new features. NOBODY. Well maybe 0.1% of your user base do. But that’s just depressing.
And I don’t mean that people don’t use any features. Most products have a handful of core capabilities that make them valuable in the first place. But everything outside that core? Good luck. We’ve spent decades inventing increasingly elaborate ways to convince users to discover functionality that our very expensive engineering teams have built.
And now, for the first time, AI might actually solve this problem. Not by making us better at feature discovery, but by making feature discovery largely unnecessary.
Which is a pretty awkward development for those of us who have spent a significant portion of our careers optimizing it (hint: ME).
Always a huge thank you to my wonderful sponsors!
SurveyMonkey's Build with AI turns a prompt into a polished, ready-to-send survey in under a minute. Trained on 100B+ questions answered and 25+ years of survey science, so growth and product teams move fast without sacrificing quality.
The before times: Feature adoption 4 life
Product was always like: Find a problem. Spec the feature to solve it. Engineer the thing. Design the interface. Create a series of product and marketing journeys to get people to that functionality. Number (should) go up. Make finance happy.
Because if a user wanted to do something, they needed to know which feature could do it, where to find it, and how to use it. And so entire teams were responsible for helping users discover and adopt all the wonderful new capabilities that we kept shipping. And don’t forget that those that DID find it, retained better. Enter growth strategy 101 - improve that feature usage.
But this created a fundamental tension that I think we’ve spent decades unsuccessfully trying to resolve.
To expand your PMF, you need to make your product more capable. But to expand your audience beyond your original core users (have you heard the term.. normies? tell me you are in a bubble without telling me you are in the bubble), you generally need to make your product simpler. More functionality creates more value, but also more complexity. And the less motivated users you’re so desperately trying to reach to expand your PMF are precisely the ones least interested in spending their Tuesday afternoon learning how to navigate your increasingly sophisticated software. Some products got so bad we even invented new term for it: software bloat. And then we started creating feature kill lists… Let’s not go there.
So we’ve spent decades trying to solve what is essentially an impossible problem: How do you keep adding functionality to increase retention and expansion of your main user base without making the product harder to use?
‘Let’s just put the new feature into the core user flow!’ suggests the earnest young PM, who hasn’t yet experienced the emotional damage of a five-year-old SaaS navigation menu. And that might work for a little bit, until your core user flow has so many features that it resembles the cockpit of a Boeing 747.
So then we simplify! We reorganize! We redesign the navigation! We hide some features to make room for new features! Maybe we even unship some features. We have a two-hour meeting debating whether something belongs under Settings or Tools. We invite 24 people to the follow up meeting about it.
And then the feature adoption numbers still suck.
So we came up with the magic of ✨Personalization✨. Instead of showing everyone everything, we’d just figure out who needed which features and expose them at exactly the right time. Wonderful idea, except large-scale personalization is really f&*^ing hard. You need complex rules, behavioral signals, segments, triggers, and an impressive amount of confidence about your ability to predict what users actually want.
This was a very difficult problem, which often required whole teams to solve. They were usually called Product, Lifecycle Marketing, and Growth teams.
What if humans don’t need to discover features at all?
But now our customers can just tell the product what they want to accomplish, and the AI figures out which capabilities to invoke.
Think about how much this changes things. We’ve always assumed that for a user to get value out of a feature, they first needed to become aware of it, understand its relevance, figure out how to access it, and learn how to operate it. Every single one of those steps introduced friction, which meant every single one became someone else’s conversion optimization problem.
But now the user can get value from functionality they don’t even know exists. They just need to communicate what they’re trying to accomplish, and the product can figure out the rest.
And I don’t think this is merely a new interface paradigm, where we replace buttons with a prompt box and call it innovation. That’s the most boring possible interpretation of what is happening.
We’re changing who actually operates the software.
For decades, humans have been responsible for navigating software and deciding which functionality to use. Now, increasingly, it’s the AI doing that work. And as agents start interacting with other products through APIs, MCPs, and various integrations, you might not even need to open the underlying software to benefit from it.
Which means the entire premise of feature discovery starts to fall apart. Why would I spend months figuring out how to get a human to click on something when the AI can just invoke that functionality at the moment it’s relevant?
And it has made me reconsider a whole bunch of things I thought I knew about building and growing software.
Case study: Me.
I started recognizing all of this by reflecting on how my own work has changed. I have spent an embarrassing portion of my career working on feature adoption. Building onboarding journeys, optimizing navigation, designing lifecycle campaigns, pushing contextual nudges, and generally trying to get people to click on stuff that we desperately wanted them to click on.
And now at Lovable? I barely think about it. I do occasionally get outraged about our agent not knowing about some feature, make a scene in some slack channel to get it fixed, but that’s about it.
Suddenly, years of professional experience trying to convince humans to use functionality are being replaced by making sure the software knows when to use its own functionality. A little rude, if you ask me.
But the feature itself hasn’t necessarily changed. What’s changed is who is responsible for deciding to use it. And I think that’s where things get really interesting for Product, Design, and Growth.
The new problem: Getting humans to trust the software
Historically, product design was largely about enabling humans to operate software. But in an AI-native product, the software increasingly operates itself. It chooses which capabilities to use, in what order, and makes decisions along the way. Which is wonderful, until you realize that the person using the software doesn’t necessarily understand what just happened. And hence they stop using said software.
This creates an entirely different product problem. How do you design an experience where the user doesn’t have to understand every step, but still trusts the process AND the result? How do you communicate which decisions the AI made, why it made them, and when human intervention is appropriate? How do you make actions reversible without forcing users to review every little thing the software does?
And I think Product work changes right along with it. For years, we optimized for getting people to use more of the product. More features, more engagement, more interactions, more usage, more logins. But what if the best product experience is one where the user barely interacts with the software at all, because it just gets the job done?
Our beloved engagement metrics might go down while actual customer value goes through the roof. That’s going to make for some entertaining growth dashboards.
But more importantly, I think the new growth opportunity becomes getting users comfortable delegating increasingly important work to software. Someone who trusts your product to complete a small task might eventually trust it to execute an entire workflow. Which means reliability, transparency, control, and trust aren’t just nice UX principles. They become actual growth levers.
But wait, there is still a discovery problem
AI can make feature discovery unnecessary, but it doesn’t automatically solve use case discovery.
This is something I’ve been thinking about a lot. When you open a traditional software product, the interface gives you some idea of what you can do. Sure, we spent decades complaining about complex navigation, but at least all those buttons and menus were communicating something about the product’s capabilities.
Now imagine opening a beautifully minimal AI-native product that gives you a prompt box and says, ‘What would you like to do?’ Great question. What CAN I do? The irony is that we’ve removed all the interface complexity that made software difficult to learn, but we’ve also removed many of the cues that helped people understand what was possible in the first place.
AI is not another feature. AI is the product.
And this is why I think so many companies are approaching AI transformation backward. They take their existing product, add some AI functionality, put a shiny little ✨ icon next to it, and proudly announce that they’re now AI-powered. Congratulations, you’ve built yet another feature that your Growth team is going to spend the next six months trying to get people to use.
We’ve managed to take the technology that could eliminate the need for feature discovery and turn it into another feature that needs to be discovered. You really have to admire our commitment to the craft.
So what are we actually building now?
Growth peeps - we can finally stop harassing people with tooltips and emails. Yay.
Instead, we need to get people to the first meaningful outcome, help them understand what else is possible, and build enough confidence that they keep delegating more to the product. Not because we persuaded them to click on another feature, but because they believe the software will actually get the job done.
Let’s have a moment of silence for our beloved Product and Growth playbooks that were built for a world where human attention was the primary constraint on feature utilization.
And if you’re feeling nostalgic about the declining importance of feature adoption, just remember: We spent decades trying to solve this problem, built entire teams around it, invented approximately 47 different kinds of in-app nudges, and still never really figured it out.
Maybe it’s time to let the machines have a go.
Edited by Jonathan Yagel.
I like this & really agree. I sometimes wonder though, if the goal is to abstract most of the friction so the user just experiences a magical outcome, at what point does the product become infra / lose the end user's touchpoint (and thus mindshare)?
Thanks for covering this important topic! I completely agree that trust is a more important barrier now when it comes to uptake. And the uncertainty aversion that comes with AI use, and not knowing the best way to use it.