GenUI: when AI generates the interface, not just the text

Most AI features today look the same: a chat box that answers with text. Generative UI, or GenUI, is the next step. Instead of replying with paragraphs, the AI composes real interface elements, such as cards, forms, charts, sliders and buttons, tailored to what the user is trying to do right now.

I have been experimenting with LLMs and agentic architectures while building Settio, and GenUI is one of the ideas I find most interesting for mobile and product engineers.

How it works

The core idea is simple:

1. The app defines a catalog of safe, well-designed components it knows how to render.
2. The AI model receives the user's intent plus a description of those components.
3. Instead of free text, the model returns a structured description of which components to show, with which data.
4. The app renders those components natively and sends user interactions back to the model.

The model decides what to show. The app stays in control of how it looks and behaves. In the Flutter ecosystem there is already experimental tooling around this idea, which makes it a natural fit for Flutter's widget-based architecture.

Why it matters

• Less friction: instead of reading a long answer, the user gets a form already filled in, or a comparison table, or a button that does the next step.
• Personalisation: the interface can adapt to the user's situation instead of forcing everyone through the same flow.
• Faster iteration: new experiences can be composed from existing components without shipping a new screen for every case.

Where it makes sense

GenUI shines when the space of possible user needs is large and hard to predict: assistants, onboarding, support, planning and data exploration. For example, helping a newcomer in Sweden understand which steps apply to their situation is a much better experience as a short, generated checklist with actions than as a wall of text.

Where it doesn't

For core flows that must be fast, predictable and familiar, such as checkout, login or payments, a designed interface is still the right choice. Users need muscle memory, and some actions must behave exactly the same way every time.

What engineers need to get right

• A strict component catalog. The model should only be able to choose from components you designed, tested and made accessible.
• Validation. Treat model output like any untrusted input: validate the structure before rendering.
• Fallbacks. Models fail and networks drop. Always have a sensible default screen.
• Latency. Stream partial results and show skeletons, so the interface feels alive while the model thinks.
• Observability. Log what was generated and how users interacted, so you can improve the catalog and the prompts.

My take

GenUI won't replace designed interfaces. It will sit next to them, handling the long tail of situations nobody had time to design for. For product engineers, the skill that matters is not prompting; it is designing good building blocks and clear contracts between the model and the app. That is classic software engineering, applied to a new kind of collaborator.