Generative UI: How AI is Redesigning Websites on the Fly

For the past thirty years, navigating the web meant interacting with interfaces designed for the average user. Layouts were static, navigation menus were fixed, and the user experience was a one-size-fits-all compromise. Over the past two to three years, a family of techniques known as "generative UI" has offered a real alternative to that one-size-fits-all model — though it's a more incremental shift than "AI redesigns your website" headlines suggest. Rather than an autonomous AI redesigning pages from nothing, what's actually shipping is large language models that choose, populate, and stream pre-built interface components in response to what a specific user is asking for, in real time.

What Generative UI Actually Is

Generative UI is easiest to understand by contrasting it with ordinary personalization. Traditional personalization shows or hides existing components — a different homepage banner for logged-in users, a recommended-products carousel based on browsing history — but the building blocks are fixed in advance and assembled by conventional code. Generative UI puts a large language model in the loop at render time: as the model interprets a user's request, it can call a specific tool or function, and the application streams back a purpose-built interface component — a comparison table, a chart, a booking widget — matched to that request, instead of a block of chat text describing the answer. If someone searching an e-commerce site asks about a specific running shoe, the system might render a sizing chart and a small comparison table rather than a wall of text — but it does this by selecting and filling in a component a developer already built, not by writing new front-end code on the fly. That distinction matters: it is closer to a very context-aware component library than to an AI freelance web designer.

The Frameworks Powering the Shift

Vercel's AI SDK has supported streaming, generative UI React components since AI SDK 3.0 in early 2024, letting developers associate specific tool calls with React Server Components that stream directly into the page as the model works — for example, mapping a weather-lookup function call to a small weather widget instead of a paragraph of text. That capability has matured considerably since, as more production apps have adopted it. A widely cited example of what's possible on top of that foundation is Morphic, an open-source AI answer-and-search engine template built on Next.js and the Vercel AI SDK; rather than tracking cursor movement to reshuffle layouts, it demonstrates how an LLM can assemble a results interface — citations, follow-up questions, structured answers — dynamically based on a user's query, using the same tool-calling pattern rather than any kind of freeform layout engine. OpenAI has since applied a related idea at much larger scale: its Apps SDK, launched at DevDay on October 6, 2025, lets developers build interactive apps with their own defined interface components that ChatGPT can call and render directly inside a conversation, so that asking about a restaurant might surface an interactive map or booking form instead of only text. The mechanism differs from Vercel's React-based approach, but the underlying idea is the same: the model decides which pre-built piece of interface best answers the moment, and what's on screen changes accordingly.

What This Isn't (Yet)

It's worth being precise about the limits of what has actually shipped, because marketing language around generative UI often runs ahead of the mechanism. No mainstream framework lets a model invent new visual design, CSS, or page structure from a blank canvas in production; what ships today is model-driven selection and population of interface components that a developer designed and coded in advance. That's a meaningful capability — it lets an interface respond to intent rather than forcing every visitor through the same fixed flow — but it is not the same as software that redesigns itself with no human-authored building blocks. Reliability is also still a live concern: because the model chooses which component to render and what data to put in it, mistakes show up as the wrong widget or a broken layout rather than a wrong sentence, which can be a more visible failure mode for end users.

The Death of the Wireframe?

Even with that caveat, the shift has real implications for how interfaces get designed. Design work is moving away from drawing a single rigid wireframe per screen and toward building a library of components and defining the rules for when the model should reach for each one. Designers are increasingly curating the boundaries within which a model can select and combine pieces, rather than dictating one fixed layout for every visitor. That is a genuinely different design discipline — closer to authoring a design system with conditional logic than to laying out a static page — and it is why teams adopting generative UI talk about component libraries and evaluation suites as much as they talk about visual design.

Generative UI is still young, and most of what has shipped lives in search, chat, and shopping interfaces rather than across the general web. Within that narrower scope, though, the direction is clear: interfaces increasingly adapt to what a person is actually trying to do, instead of asking every visitor to adapt to the same fixed page.