For as long as I've been designing, the deal has been simple. I decide what the screens look like, a developer builds them, and every user sees roughly the same thing. A thousand people open the app and a thousand people get the same dashboard.
Generative UI breaks that deal. Instead of a fixed screen, an AI model assembles the interface on the fly, based on what this person asked for, right now. Ask a travel app "compare these three hotels" and, instead of a paragraph, you get a comparison table that didn't exist a second ago.
Mostly, it changes what designers actually make. Here's what generative UI is, where it works, where it falls apart, and how to get ready for it without throwing out everything you know.
What is generative UI?
Generative UI is an interface that an AI model builds, or partly builds, at runtime in response to a user's intent. The model decides which components to show, in what order, with what data, instead of a designer fixing that layout in advance.
It's worth separating two things that often get mixed up:
- AI that helps you design UI. Tools that turn a prompt into a Figma frame or a code mock-up. That's a design-time helper. The output still gets reviewed and shipped as a fixed screen.
- Generative UI. The interface itself is composed live, for the end user, every time. No designer sees that exact screen before the user does.
This post is about the second one. It's a bigger shift, because you can't review every screen any more. You can only review the rules that produce them.
The three levels of generative UI
In practice, generative UI is a spectrum. Most real products sit at the first or second level, and I'd be wary of anyone pitching the third for a serious product today.
| Level | What the AI controls | Example | Main risk |
|---|---|---|---|
| 1. Pick a component | Chooses from a small set of pre-built cards | A chat reply that shows a booking card instead of text | Picks the wrong card |
| 2. Compose a layout | Arranges approved components and fills them with data | A dashboard view assembled for one question | Cluttered or inconsistent layouts |
| 3. Write the UI | Generates new markup and styling from scratch | A one-off mini app built from a prompt | Broken accessibility, off-brand visuals, bugs |
Level 1 is already everywhere, often without anyone calling it generative UI. Level 2 is where the interesting design work is happening. Level 3 is a great prototyping toy and a risky production pattern.
From my work
Sage, the AI assistant on my site, works at level 1. It can choose to show a resume card, a photo card or a contact card from a fixed set I designed, and it only shows one when it fits the question. The model decides when; I decided what each card looks like.
Where generative UI actually helps
The honest answer is: in the long tail. Every product has a handful of core tasks that deserve carefully designed screens, and hundreds of rare requests nobody will ever design a screen for.
Generative UI is good at:
- Turning answers into interfaces. A chart, a table or a checklist is often a better answer than three paragraphs. If a user asks "how did sales do by region last quarter", a small bar chart beats prose.
- Rare, specific tasks. "Show me only the invoices over 50,000 rupees that are overdue and from Pune" is a filter combination no designer would give its own screen.
- Progressive detail. The interface can start simple and add controls only when the user's question needs them.
It's much weaker for tasks people repeat daily. Repetition builds muscle memory, and muscle memory needs things to stay where they were yesterday.
Where it goes wrong
Consistency suffers. Jakob's law says people spend most of their time on other products and expect yours to behave similarly. Generative UI can make your product behave differently from itself, from one question to the next. That's worse.
Model mistakes become interface mistakes. If a model can hallucinate a fact, it can hallucinate a layout: a button that does nothing, a chart with the wrong axis, a form missing a required field.
Accessibility is easy to lose. Hand-built components can be tested for contrast, focus order and screen reader labels. Freshly generated markup often skips all of that. If you go beyond level 2, you need automated accessibility checks on every generated screen, not occasional audits.
You can't usability test a screen that doesn't exist yet. You test patterns, rules and a sample of outputs instead.
Watch out
Don't let generative UI become the excuse to skip designing core flows. Sign-up, payment and anything involving money or health should stay hand-designed and tested. Use generation for the edges, not the spine.
How the designer's job changes
Here's the shift I'd prepare for: you stop designing every screen and start designing the system that screens come from. That means three kinds of work get more important.
1. Your design system becomes the grammar
A generative UI model is basically a very fast, slightly chaotic user of your design system. If your components are vague, it will use them vaguely. Every component needs a clear purpose, clear rules for when to use it and when not to, and sensible defaults.
That's a good reason to clean up your library now. My post on design systems for small teams covers how to start small and keep it tidy.
2. You write rules, not just layouts
Designers will spend more time writing constraints in plain language: "Never show more than one primary button." "Money amounts always use the large figure style." "If there are more than seven rows, add a search field." These rules go into the prompt or the component metadata the model reads.
My prompting guide for designers is a good warm-up.
3. You design the fallbacks
What happens when the model is unsure, slow or wrong? Someone needs to design the loading state, the "here's a simpler view" fallback and the way back to a standard screen. That someone is you.
Tip
For every generative surface, design a boring, fixed default view first. If the generated layout fails a check or takes too long, show the default. Users forgive plain; they don't forgive broken.
A starter checklist for generative UI
If your team is exploring generative UI, here's where I'd begin:
- List your core tasks and mark them "hand-designed only".
- Pick one long-tail use case where a generated view clearly beats text.
- Start at level 1: a small set of approved cards the model can choose from.
- Write usage rules for each component in plain language.
- Design loading, low-confidence and fallback states.
- Run automated accessibility checks on generated output.
- Review a sample of real outputs every week, like a quality audit.
- Tell users when a view was generated, so they know to double-check it.
I've covered how to label AI output in visual cues for AI-generated content.
Work with us
Building an AI feature? Our AI product design agency designs copilots, agents and AI workflows that users trust.
FAQ
Is generative UI going to replace UI designers?
No, but it changes the work. Someone still has to design the components, the rules, the tone and the fallbacks that generated screens are built from. The job moves from drawing every screen to designing the system and judging its output, which arguably needs more design skill, not less.
What's the difference between generative UI and personalisation?
Personalisation usually rearranges or filters a fixed design based on who the user is, like recommended products on a home screen. Generative UI composes the interface itself in response to a specific request. In practice they overlap, and both need the same care around predictability and user control.
Can I prototype generative UI in Figma?
Partly. You can design the component set, the rules and a range of example outputs in Figma, which is the most useful part. To feel the real behaviour, a quick coded prototype connected to a model is better, and simple ones can be deployed in an afternoon for testing.
Key takeaways
- Generative UI means the interface is assembled at runtime by a model, not fixed in advance by a designer.
- Most products should start at level 1: a model choosing from a small set of designed components.
- Use it for long-tail tasks and keep core flows like payments hand-designed and tested.
- Your design system becomes the grammar the model writes with, so clear component rules matter more than ever.
- Always design a fixed fallback view for when generation is slow, unsure or wrong.
What to do next
Generative UI rewards teams with clean design systems and clear rules, and punishes teams that hoped AI would make design decisions for them. If you want a deeper look at how I approach AI products, the Pukaar.ai case study shows how I designed an AI feature people could trust at their worst moment.
Thinking about adding AI-driven views to your own product? Tell me about your project and I'll help you work out where generation helps and where it doesn't.