Generative UI: How AI Builds an Application Interface Right Before Your Eyes

You ask a chatbot to compare two pricing plans, and instead of a block of text, you get a table, a graph, and a button. An interface that wasn’t designed by a human as a pre-made screen, but was put together by artificial intelligence specifically for this one query. This is exactly what’s known as generative UI. It really works, but the way it happens is less magical than is often described.

What Is Generative UI

In the traditional approach, developers design all the screens and states of the application in advance. With generative UI, a model—specifically a language model—decides which components to display, how to arrange them, and what data they contain, based on what the user currently needs. Descriptions of these technological approaches refer to an architecture where the interface is generated in real time and is not hard-coded.

What matters is exactly what the model creates. There are three main approaches, which differ in the degree of freedom granted to the AI.

Three Ways AI Creates Interfaces

Static: AI selects from pre-built components

Developers pre-program a set of components, such as a product card or a chart. The model only decides when each component appears and what data to populate it with. This is the safest and most predictable method, but also the least flexible: the agent can only display what has been prepared in advance.

Declarative: AI describes the structure

The model does not return code, but rather a structured description of the interface: a tree of abstract components, such as cards, rows, text fields, or input fields, along with the data with which they are to be populated. The application renders them from a pre-approved catalog of components. The A2UI protocol, published by Google in late 2025, is based on this principle. The interface is transmitted as a stream of small JSON records, and crucially, it consists of data, not executable code. This simplifies security.

Open: AI Generates the Code Itself

The model generates the interface code directly. This approach offers the greatest flexibility but is the most difficult to secure and control. It is expected that most production solutions in banks or e-commerce sites will rely primarily on the first two approaches.

How It Works in Practice

Imagine that in a mobile carrier’s app, you enter a request to compare your plan with another package. The system calls upon available tools to retrieve data, selects appropriate components—such as a usage graph and a comparison table—and displays them. The user can then click through; the changes are sent back to the agent, who updates the interface. This cycle (the agent designs the interface, the user interacts with it, the agent adjusts it) is at the heart of the entire concept.

Such examples are currently mostly demos and prototypes. We have not found any information on how widespread generative UI is in mainstream banks or e-commerce sites, and we do not assume it to be widespread in this text.

What’s Changing for Designers and Developers

The work isn’t disappearing—it’s changing. Instead of designing every screen, the team prepares a high-quality library of components and rules for how they can be combined. Declarative solutions are only as good as the catalog from which the AI draws, and they require a carefully designed design system. So someone is still designing the interface—just at a different level.

Risks and Open Questions

• Bad data or strange layouts. With a static approach, a good component might display nonsensical data based on its descriptions; with a declarative approach, good components might result in a strange layout.
• Security. The more freedom the model is given, the greater the risk. That is why catalogs of approved components and data transfer are used instead of code.
• Predictability and Accessibility. This is our conclusion, not a claim from the source: if the interface changes with every query, it becomes harder for people to learn where to find things, and it’s harder to guarantee that every version will be usable, for example, by screen readers.
• Accountability. For services such as financial services, it must be clear that the data and buttons do exactly what they show.

Are static websites a thing of the past?

No. Static pages and traditional navigation will remain for a very long time in areas where stability and predictability are important. Generative UI is currently appearing mainly in assistant interfaces, analytics, and tools where users choose from a large number of options. We have no basis for claims that complex menus will “soon be a thing of the past.”

Conclusion

Generative UI is a meaningful way to let an assistant respond not only with text but also with a usable interface. However, the most realistic scenarios are not “AI
writing an entire website,” but rather the controlled assembly of pre-made, approved components. What will be decisive is not so much the capabilities of the models as the quality of the components and the trust in what appears on the screen.