The Interface Is Now Part of the Answer

ChatGPT recently asked me to choose a direction before it answered.

I had given it a broad writing request. Instead of immediately producing a confident interpretation, it generated several possible approaches and placed them inside a small selection interface.

I could click the direction I wanted instead of explaining it from scratch.

At first, this looks like a minor usability improvement: a multiple-choice question inside a chat.

But something more interesting has happened.

ChatGPT did not only generate text. It generated part of the interface required to continue the interaction.

The container was probably predefined. A designer had already decided how the question card, options, buttons, and text field should behave.

But the system decided:

• when the interface should appear
• which question needed to be asked
• which options were relevant
• how those options should be worded
• how the answer would alter the next step

This makes it a small form of generative UI.

Not fully generated. Not particularly visually ambitious. But generated enough to reveal where interfaces may be going.

The AI is no longer only producing the answer.

It is beginning to produce the temporary interface needed to reach the answer.

Generative UI is not one thing

Generative UI broadly describes an interface constructed or adapted at runtime according to the user's intent and context.

That definition can cover radically different experiences.

A generated set of three buttons fits.

So does a custom dashboard assembled from a design system.

So does an entire interactive application written and rendered specifically for one prompt.

Calling all of them generative UI without distinction is not especially useful.

The important question is not simply whether an interface is generative.

It is:

How much of the interface is being generated?

These levels are not a maturity ladder.

Level 3 is not automatically better than Level 1.

Each level trades predictability for adaptability.

Level 1: Generated choices

ChatGPT's guided-choice card belongs at the first level.

The visual component is stable. What changes is its meaning.

The system generates a question such as:

Which direction should this article take?

It might then generate several options:

UX design principles

Psychological analysis

Product strategy

Personal reflection

The user can recognize the intended direction instead of articulating a complete brief.

Claude uses a similar pattern. It can present multiple-choice, multi-select, and ranking interactions when it needs more information. Claude Code also exposes a structured question mechanism through which the model supplies the question and possible answers while the surrounding application renders the controls.

This is generative UI at its smallest practical scale.

The AI does not invent a new visual system. It generates the decision that the visual system should contain.

That might sound less impressive than producing a full application, but it solves one of the most persistent problems in conversational interfaces: users often cannot clearly explain what they want.

The blank prompt box asks people to transform an incomplete feeling into a precise instruction.

This requires them to know:

• what the AI can do
• which information is relevant
• which distinctions matter
• what a good result should look like

The guided-choice interface moves some of that work into the system.

The user no longer has to generate the entire prompt.

They can begin vaguely, inspect the model's interpretation, and select the closest direction.

This turns prompting from an act of pure articulation into an act of recognition.

The interface exposes interpretation

The most important part of Level 1 generative UI is not convenience.

It is visibility.

Normally, when a user gives an ambiguous prompt, the model quietly chooses one interpretation. It then writes as though that interpretation had always been obvious.

The uncertainty disappears before the answer appears.

Generated choices expose that hidden moment.

The model effectively says:

I see several plausible versions of your request. Choosing between them would change the result enough that I should not decide silently.

That is a more honest interaction.

But it is also a powerful one.

The system decides which possibilities become visible. Four neat options can make the possibility space appear complete even when the AI has merely generated four plausible guesses.

Every generated choice is also a generated frame.

A good version therefore needs an escape route: free text, an Other option, combination of choices, or the ability to skip the question.

Without that escape route, guidance becomes control.

Level 2: Generated composition

At the second level, the AI does more than fill a predefined component with generated text.

It decides which components should appear and how they should be assembled.

The underlying building blocks may still be designed, tested, and approved in advance:

• cards
• maps
• timelines
• charts
• comparison tables
• filters
• image galleries
• sliders
• accordions

The AI does not necessarily write a new interface from scratch. It composes an interface from a controlled vocabulary.

Google's Gemini Visual Layout is an example. Google describes it as a model-generated, magazine-style response made from photos and interactive modules. A trip-planning prompt might become an explorable visual itinerary rather than a conventional chat response.

The structure depends on the request.

A travel plan might need a map, daily timeline, and accommodation cards.

A product comparison might need a sortable table and price filters.

A historical explanation might need an illustrated chronology.

A financial question might need a chart, assumptions panel, and scenario controls.

The interface is no longer selected from one fixed page template. It is composed around the information and the task.

The design system becomes a language

Level 2 generative UI changes the role of a design system.

Traditionally, a design system is a collection of components used by designers and developers to construct products.

In generative UI, it can become a language the model uses to communicate.

Instead of producing arbitrary code, the model might request:

• one timeline
• three comparison cards
• one map
• one adjustable price filter
• one confirmation button

The client application then renders those instructions using trusted components.

Agent-driven interface specifications such as Google's A2UI project follow this general architectural direction. Rather than transmitting arbitrary executable interface code, an agent can send a declarative description of the interface. The receiving application renders it with native or approved components.

This approach limits visual freedom, but improves consistency, accessibility, and security.

The model controls the composition.

The product team still controls the parts.

This may become the most practical form of generative UI for mainstream products.

Banks probably should not generate a completely new transfer interface for every customer.

But they might generate a task-specific financial view using approved charts, tables, warnings, and confirmation components.

Healthcare systems probably should not invent new medication controls in real time.

But they might assemble a personalized treatment overview from clinically reviewed interface modules.

Level 2 allows the interface to adapt without abandoning product governance.

Level 3: Generated applications

At the third level, the model generates not only the content and composition, but also much of the interface's behavior.

It may write code, create interaction logic, determine the visual structure, and construct a temporary application for a specific task.

Google's Gemini Dynamic View is a direct example.

Google says Gemini can design and code a customized interactive response in real time. A prompt about Van Gogh might become a navigable gallery. A question about probability might become an interactive educational tool. An event-planning request might become a purpose-built planning interface.

Google Search's AI Mode has also explored generating interactive tools and simulations for individual questions rather than returning only links or text.

Claude can generate custom visuals inside a conversation, including diagrams, interactive charts, and other elements whose layout and logic are produced for the user's current question.

At this level, the distinction between an answer and an application begins to collapse.

Ask a question about compound interest and receive a calculator.

Ask how an engine works and receive a simulation.

Ask for help planning an exhibition and receive a spatial planning tool.

Ask for fashion advice and receive an interactive gallery with filters, combinations, and recommendations.

The application may exist for only one user, one task, and one conversation.

It does not need to become a permanent product.

Software becomes temporary

Traditional software requires enough repeated demand to justify building a stable interface.

A team identifies a recurring problem, designs a product, develops it, tests it, and distributes the same application to many users.

Generative UI weakens that economic requirement.

An interface can be worthwhile even when only one person uses it once.

The software exists because the current task requires it.

Then it disappears.

This creates a category of temporary software situated somewhere between an answer, a prototype, and an application.

The AI is not choosing which existing app the user should open.

It is creating the smallest app needed for the present moment.

Research into generative interfaces supports the value of moving beyond linear chat. One study reported strong user preference for task-specific generative interfaces across a variety of evaluated tasks. Google's own research has also found that human raters often preferred generated interactive responses to standard model responses when generation time was excluded.

The qualification about speed matters.

A custom interface may be more useful, but it is also slower and more expensive to create than a paragraph.

More generative means more unpredictable

The three levels introduce progressively larger spaces of possibility.

At Level 1, the system might generate a bad label.

At Level 2, it might choose the wrong visualization or bury the most important information.

At Level 3, it might produce broken interaction logic, inaccessible controls, inconsistent patterns, or misleading simulations.

The interface can hallucinate too.

Not only its content, but its affordances.

A button may appear to perform an action that is unavailable.

A chart may suggest precision unsupported by the data.

A generated control may behave differently from familiar platform conventions.

A temporary app may look trustworthy despite never having been inspected by a designer, developer, or accessibility specialist.

This makes interface generation different from text generation.

A wrong paragraph can misinform someone.

A wrong interface can misinform them while also encouraging action.

The closer generative UI gets to operational systems such as money, health, identity, and permissions, the more constrained it needs to become.

The most generative interface is not always the most responsible interface.

AI-generated UI is not always generative UI

There is also an important distinction between generative UI and AI-generated interface design.

Tools that produce websites or app screens from prompts are often called generative UI tools.

They do generate interfaces.

But many of them operate during product creation rather than during product use.

A designer asks for a dashboard.

The AI generates code or a mock-up.

The team reviews it, edits it, and publishes it as a persistent product.

That is AI-assisted software production.

Runtime generative UI behaves differently.

The end user expresses an intention, and the product constructs an interface for that user's immediate situation.

The difference is not what technology produced the pixels.

The difference is when and why the interface was produced.

A website generated once and served to everyone is still a static interface from the end user's perspective.

A small choice card generated uniquely for the current conversation may be more genuinely generative, even though it looks much simpler.

The right level depends on the uncertainty

The industry may be tempted to push every interaction toward Level 3 because fully generated mini-apps look more futuristic.

But the goal is not to maximize interface generation.

The goal is to match the interface to the uncertainty of the task.

Use Level 1 when the main problem is deciding what the user means.

Use Level 2 when the information is known but needs a task-specific structure.

Use Level 3 when understanding or completing the task genuinely requires custom behavior.

A user asking for an article direction probably needs three buttons, not an application.

A user comparing twenty apartments may benefit from filters, a map, and a ranked table.

A student trying to understand orbital mechanics may benefit from a generated simulation.

Generative UI should expand only as far as the task requires.

Anything beyond that is interface theatre.

The blank box becomes an interface generator

The first era of consumer AI was represented by a blank text field.

Its message was simple:

Ask anything.

That openness made AI feel universal. It also transferred much of the interaction design to the user.

Users had to know how to ask, what to specify, and how to repair an incorrect interpretation.

Generative UI changes the relationship.

The blank box becomes a starting point rather than the complete interface.

The user expresses an incomplete intention.

The system generates the next useful structure.

Sometimes that structure is a question with four choices.

Sometimes it is a report assembled from cards and charts.

Sometimes it is a temporary application that has never existed before and may never be needed again.

ChatGPT's guided-choice interface is therefore more than a convenient clarification pattern.

It is Level 1 generative UI entering the mainstream.

It shows that the future of AI interaction may not be a better chatbot.

It may be a system that decides, moment by moment, whether you need a sentence, a button, a map, a simulation, or an entirely new interface.

The answer is no longer confined to the content.

The interface itself is becoming part of the answer.

AI authorship note

This essay grew from Kris Haamer noticing ChatGPT's guided-choice clarification interface and asking whether it should be understood as generative UI. AI supported the research framing, the three-level model, examples, drafting, editing, visualization, and implementation. Kris identified the interface pattern, directed the generative UI perspective, requested the three levels, and made the decision to publish it.

Connected reading

• The End of the Software Request
• Software for One Afternoon
• The Browser Is Becoming the Agent's Body
• The Product Is Becoming an Organization