Ask five people in this industry what generative UI is and you’ll get five confident answers that don’t match. A founder will describe a demo where the screen builds itself out of thin air. A designer will describe the tool that turned a prompt into nine mockups before lunch. An engineer will describe a React component streaming out of a tool call. And somebody on LinkedIn will describe the end of interfaces entirely, illustrated with a glowing orb.
The term is young. The first serious definition is barely two years old, and young terms are worth fighting over, because whichever definition hardens first is the one everybody builds toward. So here’s mine, stated plainly, from someone who ships these systems rather than posts about them:
Generative UI is the interface being decided at the moment you need it, instead of months in advance. A model looks at who you are, what you’re trying to do, and what just happened, then assembles the right surface for that moment from parts a team already made trustworthy. Generative UI, GenUI if you’re in a hurry, gen UI if you’re in a comment section.
That definition has three phrases doing all the work: at the moment, assembled, and parts a team already made trustworthy. The rest of this is really just those three phrases, taken seriously.
The decision moved
Every interface you’ve ever used was decided before you arrived. That’s no criticism of anyone. It was the only method available. You research the users, you map the flows, you anticipate the paths, you draw the screens, you ship. From that moment the interface is frozen, and every person who shows up (the first-timer, the power user, the one at 2am with a problem) walks into the same building through the same doors.
If you’ve ever watched a real person take the “wrong” path through a flow you spent weeks anticipating, you know the feeling. The map was drawn before the traveler showed up, and the traveler didn’t read the map. So we built our compensations: onboarding tours, empty states, settings pages, progressive disclosure, an FAQ. All of it is design absorbing the cost of one hard constraint… the interface had to be finished before anyone used it.
Generative UI removes that constraint. The software ships with parts and rules instead of finished screens, and when a request lands, a model composes the surface right then, for that person, for that moment. The decision about what the interface IS moves from design time to run time. That single sentence is the whole technology. Everything else is consequences.
A definition being born in public
You can watch this term getting negotiated in real time, which is rare. Most design vocabulary arrives pre-fossilized. This one has receipts.
In March 2024, Kate Moran and Sarah Gibbons at Nielsen Norman Group put down an early stake: a generative UI is “dynamically generated in real time by artificial intelligence to provide an experience customized to fit the user’s needs and context.” They paired it with a quieter idea, outcome-oriented design, that I’ll come back to, because it turns out to be the important half.
Then the toolmakers made it concrete. Vercel’s AI SDK turned it into a pattern any product team can ship: the model decides to call a tool, the tool returns data, and the data renders as a live component instead of a paragraph. The chat message that’s secretly software.
Then the platforms moved, fast and in the same direction. In October 2025, OpenAI put apps inside ChatGPT: real interactive interfaces (maps, playlists, booking flows) growing directly out of a conversation. A month later, Google shipped generative UI in Gemini, where the model designs and codes a fully custom interactive page in response to any prompt. And in January 2026, the Model Context Protocol grew official UI capabilities, which is the moment the argument quietly ended. Nobody standardizes plumbing for a thing they expect to go away.
Every major platform has now concluded the same thing: the text box was only ever the on-ramp. I made the longer version of that argument in GenUI Is Not a Chat Window. The short version is that a blinking cursor asks the user to do the interface’s job.
Four things it isn’t
A definition earns its keep by what it excludes. Here’s what keeps getting sold under this name that doesn’t belong.
It isn’t AI-generated mockups. The prompt-to-design tools are genuinely useful, and they’re a different thing. When a tool generates nine screen options and a designer picks one to ship, the generation happened at design time. The output is frozen before a user ever touches it, same as it ever was. That’s a faster pencil. A faster pencil changes the sketching, and it changes nothing about when the interface gets decided.
It isn’t a chatbot with widgets sprinkled in. Dropping a card into a transcript is progress, and if the conversation is still the architecture (if every task starts with the user composing a paragraph), you’ve decorated the text box, you haven’t replaced it. The giveaway is who does the work of figuring out what’s needed: the system, or the person typing.
It isn’t infinite novelty. The maximalist reading, where every screen is unique and anything can appear, is the pole Google’s demo lives at, and it’s spectacular for what it is. Worth noting: their own research team runs post-processing to catch the model’s mistakes before showing the result. A research preview can afford that. Your checkout can’t.
It isn’t personalization with a new badge. Recommendation engines have rearranged content inside a fixed frame for twenty years: same shelf, different books. Generative UI decides the shelf. If the frame itself (what controls exist, what’s shown, what’s asked of you) can’t change, it’s personalization. Which is fine. It’s just a different thing.
Composed, not conjured
So if the honest version isn’t “anything can appear,” what is it? Picture a spectrum with three stops.
At one end, static: the interface we’ve always shipped. One building, every visitor, all the compensations design can muster. At the far end, conjured: every surface generated from scratch, every session a blank sheet. And in the middle, the stop that actually ships: composed. A library of components and interaction patterns the team has pressure-tested, and a model that selects and arranges them for the moment, without the authority to invent new ones.
The reason products live in the middle is trust, and trust is the interface keeping its promises. The button you used yesterday behaves the same today. The destructive action sits far from the safe one, every time, on purpose. Conjured interfaces renegotiate those promises every session, which is why they demo beautifully and ship rarely. Composed interfaces keep the promises while changing the composition, which is what a great human assistant does too: same trusted moves, arranged for the situation in front of them.
Where the design went
Here’s the question underneath the whole topic, the one my industry keeps asking with a nervous laugh: if the model assembles the interface, what’s left to design?
Everything that makes the assembly worth trusting.
Someone designs the parts. A component library that can cover a thousand moments with twelve patterns doesn’t fall out of a model. It’s carved, argued over, pressure-tested, and pruned. Deciding what makes the cut (and what stays out, which is the harder half) is taste, applied at the system level. This is the work I’ve done for twenty years, and GenUI didn’t shrink it. It promoted it: the design system stops being the foundation and becomes the runtime.
Someone writes the rules. This is Nielsen Norman’s outcome-oriented design, and it’s the half of their 2024 piece everyone should’ve underlined: designers stop specifying every screen and start specifying goals and constraints the system composes within. In practice that means intent, written down where the machine has to obey it. Which patterns exist. When each earns its place. What never appears next to what. I’ve watched written intent discipline a model the same way it disciplines a freelancer (the brand kit was the easy part). An orchestrator without written rules doesn’t compose, it wanders.
Someone still judges the output. The design review doesn’t disappear, it points at behavior instead of artboards. Did the right surface show up, at the right moment, for the right person? You’re critiquing a probability distribution now, and it’s still critique: it needs an eye trained enough to catch what’s off and the standing to say so. Teams doing this well write evaluations for their orchestration the way they used to review flows, and the ones doing it badly find out from their users.
Notice what all three have in common. They’re upstream of the model, they’re written rather than implied, and they’re exactly the skills design has been building for two decades under other names: systems, principles, critique. The job didn’t vanish. The deliverable did, and what replaced it is more leveraged than any Figma file ever was, because it shapes every screen the system will ever compose, including the ones nobody predicted.
The opening move
I said at the top that young terms are worth fighting over. This is me fighting for one, because the losing definitions are already circulating: GenUI as mockup generator, GenUI as chatbot garnish, GenUI as the end of designers. Each one is wrong in a way that leads teams somewhere expensive.
There’s a longer story behind this piece, and this is its first page. How you translate a brand into rules a machine can hold. What critique looks like when the artifact is behavior. How a team restructures when the seam between design and engineering becomes the product. I’ve been circling those from different angles in the journal for a while; consider this the piece they all connect back to.
Twenty years ago the job was drawing the building. Then it was drawing the system that drew the building. Now it’s deciding which buildings a machine may offer, moment by moment, and checking its work. Different tools every decade. Same question every time: does the thing in front of a person actually help them, and is it good?
What is generative UI? It’s the interface, deciding late. Design is how it decides well.