The chat box used to be a constraint.
You asked. The model answered. If the answer needed a calculator, a comparison table, or a form, the user had to carry it somewhere else.
OpenAI’s GPT-6 launch changes that boundary. Its Intelligent UI can choose text, visuals, buttons, forms, charts, and small interactive tools while composing an answer. A prompt can produce the interface the moment requires instead of routing every task through the same blank rectangle.
That sounds like a presentation upgrade. It is really a product-state problem.
A generated interface still makes commitments
A normal product screen has an owner, a release history, and a reasonably stable shape. A generated screen may appear once, for one person, in response to one phrasing.
The interface still makes consequential choices. A comparison can decide which attributes deserve columns. A calculator can hide an assumption in a default. A form can make one path feel official and another path feel exceptional.
Those choices need to be inspectable even when no designer placed every component by hand.
There is a versioning problem too. If the model regenerates a mortgage calculator after a follow-up, did it edit the original tool or create a new one? A user needs to know which numbers belong to which assumptions. Temporary software can still produce durable decisions, so the product should preserve enough provenance to reconstruct the path without turning every answer into an audit log.
OpenAI’s release notes say ChatGPT can choose the format automatically and return to plain text when that works best. Its developer guidance makes a similar point for apps: use cards, carousels, or full-screen views when visual interaction improves the workflow. The useful principle is restraint. The system should generate the smallest interface that improves the decision, not the largest one it can render.
Preserve the conversation underneath
An interactive answer should not become a cul-de-sac.
If a user adjusts a slider, filters a comparison, or fills part of a form, the product needs to keep three things clear:
- what changed
- which assumptions produced the current state
- how to continue in plain language
That third item is the escape hatch. A person should be able to say, “Use the cheaper option, but keep the warranty,” without reverse-engineering the temporary interface. OpenAI’s UI guidance explicitly keeps the composer available over full-screen views so the user can keep talking to the app in context.
The screen should also narrate meaningful changes. A recalculated total, removed constraint, or submitted action deserves a compact confirmation in the conversation. Otherwise the visible card and the conversational record can disagree. The user is then left unsure which one the product considers current.
This is where generated UI becomes more than a prettier answer. The interface and the conversation share state. Lose that connection and the product creates a new handoff: the user must explain the screen back to the model. I have argued that platform strategy should count the handoffs it removes. The same test belongs here.
Measure recovery, not just delight
The obvious launch metrics will be interaction rate, task completion, and whether people prefer an interactive answer to a text wall. Those are useful. They favor the happy path.
I would also measure recovery: how often people undo an action, reopen an assumption, switch back to conversation, or abandon a generated tool because its state became confusing. Watch whether a follow-up prompt changes the existing artifact or produces a competing version beside it. Test whether the user can explain what the tool did after a minute away.
One practical review asks four questions before an interface appears:
- What decision does this control help the user make?
- Which defaults or assumptions must stay visible?
- What state has to survive the next message?
- Can the user finish the task without learning the interface?
Generative UI can remove the little translation jobs between an answer and an action. That is genuine product progress.
But the best temporary interface should feel disposable without making the user’s work disposable too.
Comments
Comments are powered by GitHub Discussions through Giscus.