Generative Interfaces
Apps were built for a world where software couldn’t understand you. That world is over.
Open your phone and count the apps on your home screen. Every single one was built around the same assumption: you need a dedicated place to do a specific thing. Travel in one container. Money in another. Calendar separate. Notes separate. Fifty specialists in your pocket, and you’re the only one connecting them.
That assumption made sense for a long time. Software couldn’t understand plain language, so you had to speak its language instead. Learn where the buttons were. Follow the flows it prescribed. Adapt yourself to the tool. The interface was a layer you had to master before the software could help you.
That layer is now disappearing.
Why every app looks the same
Every piece of software ever built shares the same flaw: it was designed for everyone, which means it was designed for no one. The same buttons, the same flows, the same onboarding - for the enterprise buyer and the solo freelancer and the student, all at once. Building software was expensive, so companies spread that cost across as many users as possible and hoped people would adapt.
Adapting meant learning. Learning took time. Every piece of software you’ve ever used started out costing you something before it gave you anything back.
That was the deal and you accepted it because there was no alternative. Now there is.
What a generative interface is
For most of software’s history, an interface was something designed in advance - fixed menus, set flows, predetermined options. You opened an app and found a structure someone else had decided on. Your job was to navigate it.
A generative interface has no predetermined rules. It assembles itself from context, in the moment, for this person and this task. The smarter the system, the less UI you need.
Think about booking a flight. Today: open the app, search by date, filter by price, scroll through options, click through to seat selection, enter payment, confirm. Twelve steps, if nothing goes wrong.
A generative interface knows your calendar. It knows your preferences. It knows who you’re traveling with and whether you prefer aisle or window. You say “I need to get to Stockholm for a Lovable event” and it comes back with three options, pre-filtered, ordered by what actually matters to you. You pick one. Done. The interface generates itself around the task and vanishes when the task is complete.
The app of the future isn’t a place you go. It’s the response that appears when you need it.
The app store era is ending
When Steve Jobs announced the App Store in 2008, the model felt inevitable: every function in its own container, discoverable in a marketplace, downloaded to your device. Each app was a specialist you hired for a specific job. The problem with specialists is that they don’t talk to each other - and you’re the only one doing all the coordination.
Generative interfaces change that. You don’t need fifty separate apps. You need one system with enough context about you to surface the right thing at the right moment. The capabilities remain but the different containers dissolve.
There’s a second disruption happening alongside this one. People aren’t just navigating apps differently - they’re skipping them entirely. AI can now turn a plain language description into working software in minutes. You don’t need to know how to code. You describe what you need, and the software gets built.
I see this happening at Lovable every day. Users aren’t primarily technical founders. Many are individuals solving personal problems - workflows they couldn’t find apps for in random marketplaces. A custom CRM shaped to how their sales process works. A tracker for one metric no existing dashboard exposes. They basically just build it, use it, and move on.
The distance between “I need something” and “I have a something” is fundamentally collapsing. Downloading someone else’s app - with all its compromises and onboarding flows and pricing tiers - is starting to feel like the slower option.
I don’t think apps will disappear overnight. But there’s some real change happening and the more I think about it the more I get excited about these two directions. Interfaces are becoming generative on demand and users are becoming builders instead of consumers.
The patience problem
There’s also a psychological shift happening alongside the technical one, and it might be the more consequential.
Every time software gets faster and more responsive, our tolerance for friction shrinks. It happened with page load times. It happened with streaming. Each improvement in convenience doesn’t just satisfy us but radically recalibrates what we’re willing to put up with.
Think about it. Generative interfaces are doing this at a different scale. When software can understand what you need and handle it directly, navigating a ten-step flow doesn’t just feel inefficient. It feels completely broken. The baseline and expectation of people is different now.
And it compounds. The more capable generative interfaces become, the more impatient users get. The more impatient users get, the less forgiving they are of anything that makes them do unnecessary work. It’s a one-way street. Expectations do not reset.
For anyone building software today, this is something you need to take into consideration: you’re not just competing with other apps in your category. You’re competing with the experience of software that simply understands you. It’s a moving target, and it’s moving fast.
What comes next
It seems like building apps for everyone was always a workaround. We built containers because software couldn’t meet us where we were. Now it can.
What’s interesting about this moment is not just the technology but also the timing. Interfaces are becoming generative at exactly the same moment users are running out of patience or building products simply themselves.
Most companies won’t see this coming, but I can promise you all of these observations are happening already today. Don’t optimize onboarding flows or debate about navigation structures. Go figure out how you can build a system around context so you are perfectly equipped for the new era of generative interfaces.
When I think about this long-term it’s pretty clear to me that interfaces assemble themselves on demand, around a task, and disappear when it’s done. But the short-term implication is just as important, and more perhaps even actionable: you need to deliver value before the user has time to lose patience.
I call this instant value. Strip everything that doesn’t directly serve the reason someone showed up. No lengthy onboarding. No tutorial screens. No warming up. The first moment a user touches your product should already be giving something back. Not promising value but delivering it.
There’s a tension worth naming here. Instant value gets people in. But trust is what keeps them. And trust is harder to build when the interface is generated on demand. In a world of generative interfaces, trust will have to come from somewhere else: from consistency of outcomes, from transparency about what the system knows and how it’s using it, from the feeling that the AI is working for you and not around you. It’s a design problem nobody has fully solved yet. But it’s the right problem to be working on.
Interfaces aren’t going away. They’re just no longer designed in advance -they’re generated on demand, for you, in the moment you need them.
On demand Interface based on my preferences and context..Interesting perspective..How long do you think this will take to come to reality.?