The Future of Generative UI

Every major design tool company shipped an AI feature in 2025. Most of them generate interface components inside the chatbot. You ask about revenue, and it builds a graph inside the chat. You ask for a plan and it asks follow-up, multiple-choice questions. This is generative UI today. It's useful, but it's early.

The real question is what happens when generative UI gets better at understanding what to build, and when to build it, without being asked.

Claude can create charts and interactive components mid-conversation. You describe what you want, and it renders a working visualization right in the chat window. Cursor asks clarifying questions about your project plan before generating code. Wabi builds hyper-personalized interfaces through a conversational flow.

These are real advances. But they share a constraint: the chat window. Everything happens inside a text input and a response stream. The generated output is a reply in a conversation, not a persistent part of the product.

The next phase is when generative UI breaks out of the chat box. When the product generates the right interface based on real signals, without waiting for a prompt.

In the future, the product itself starts adapting based on how someone uses it. What surfaces first, what gets suggested, what gets hidden. The software gets better at listening and interpreting intent. What makes this possible is better signal intake.

Two types of signals matter: explicit and implicit.

Explicit signals are things a user tells the agent directly. Again, this is the chat interface. I go to Posthog and ask how onboarding stats have been over the last month, and it generates a table. This interface element was generated after a specific ask led the Posthog agent to interpret that it would be valuable to show the data in a table.

Implicit signals are the ones the user never consciously sends. How long they spend on a screen, which features they ignore or never use, what they search for in the help docs, what they complain about on a customer support call. These signals are harder to capture, but they tell you what's actually happening.

As signal intake gets more sophisticated, generative UI stops being something you prompt and starts becoming something the product does on its own because the user's behavior told the system that something was missing, wrong, or underemphasized.

That's the shift: from generating what you asked for to generating what you need.

With an eye on the industry, it's easy to see what will enable more fluid, signal-driven software.

Data loops are closing.
Boris Cherny at Anthropic has been speaking about this. Products are getting better at feeding their own usage data back into their decision-making. The gap between “we collect analytics” and “the product acts on analytics in real time” is shrinking. What used to require a product team reviewing dashboards and shipping updates can start happening autonomously.

Integrations are getting easier.
The cost of connecting systems keeps dropping. APIs, webhooks, and agent-to-agent communication mean a product can pull context from the tools a user already relies on. Calendar data, CRM records, communication patterns. Each integration adds signal density without adding user effort.

Agentic coding is fast and getting faster.
The speed at which an AI agent can generate functional, tested code has changed what's buildable. Features that would have taken a team a sprint to ship can be prototyped in hours. This matters because signal-driven generative UI requires a lot of small, context-dependent adjustments. The economics only work when making those adjustments is cheap.

Near term: more sophisticated chat components.
The chat interface isn't going away. It's going to get better. Expect richer interactive elements inside conversational AI. Charts that update as you refine your question. Forms that pre-fill based on your history. Multi-step workflows that live inside a chat thread. This is generative UI getting sharper within its current container.

Mid term: automated customer success.
The product responds to friction before the user files a ticket. If someone keeps visiting the same help article, the product surfaces the answer proactively. A Zendesk ticket leads to a bug fix Linear issue getting created, tracked, completed, and pushed. Customer success stops being a team and starts being a capability built into the product itself.

Long term: the product reshapes itself around each user.
The product's behavior, priorities, and information hierarchy are shaped by each user's actual patterns. Two people using the same product have different experiences, because the product has learned different things about them. No one configured this. No one filled out a form. The product watched, inferred, and adapted. This is generative UI at full maturity. It generates the right experience for each person, continuously, based on real usage.

Three things have to be true.

Design systems have to support it.
This requires a library of functional, accessible, on-brand components that an agent can assemble and swap without breaking the product. If your design system only exists as a Figma file, it can't participate in runtime decisions. The system needs to be code-native, well-documented, and flexible enough to handle combinations that a human designer never explicitly approved.

Agents need design guidelines.
A design.md file, or something like it, that tells the agent what to use and when to use it. What component is appropriate for a list of 5 items versus 500. When to use a modal versus inline expansion. What tone to use in microcopy. These are decisions designers make instinctively. Agents need them written down.

Signal capture has to be invisible.
This is the hardest part and the most important one. You cannot ask people to put in extra effort to make the product smarter. It has to come through natural behavior. The data that powers this comes from customer support calls, behavioral patterns, help ticket language, time-on-task, navigation paths, and error recovery sequences. If collecting this data requires the user to do anything extra, most users won't do it, and the system stays dumb.

On the consumer side, an interface that rearranges itself every time you open the app is going to lose users. People build muscle memory. They expect the settings icon to be in the same place. They expect their dashboard to look the way it looked yesterday. An experience that changes too aggressively doesn't feel personalized. It feels broken.

On the enterprise side, the problem is even sharper. Companies invest in training materials. They build SOPs around specific workflows. If the software interface shifts based on individual usage patterns, the training materials become obsolete. An employee who learned the product last month is looking at a different product today. That slows people down instead of helping them.

If a user has to relearn how to use a product every time they open it, the product won't survive long enough to prove its thesis.

Beyond the end user experience, generative UI has the power to change how entire industries hire and work. The software development process no longer needs to be made up of PMs, designers, and engineers. Responsibilities become a lot more fluid, and diversity in thought becomes more valuable in creating more well-rounded systems.

Designers will own the design architecture, and in the foreseeable future, provide input on taste and polish. When humans instigate product expansions and changes, it will be informed by the work product designers do. It will be more about equipping engineers, whether agentic or human, with the tools and knowledge to make the product better.