4 posts tagged with "generative-ui"

There is a number that should end the "let's add a chatbot" reflex on its own: in a large fraction of AI features, most of the people who open the chat window never send a single message. Reported figures cluster around 60% abandonment before the first message, versus far higher engagement when the same capability is wrapped in a designed empty state with examples and one-tap starting points. The model didn't fail. The answer was never generated, because the question was never asked. The user opened a blank box, felt the cursor blinking at them, and left.

We reached for chat because it was the path of least resistance, not because it was the right interface. The moment a language model could hold a conversation, "talking to the AI" became a synonym for "using the AI," and every product team inherited the same default: a text box, a send button, and a promise that the model will figure out the rest. That default is quietly wrong for most of the work agents actually do.

Chat is a fine input primitive. It is a terrible operating environment. Those are different claims, and conflating them is how you end up shipping a blinking cursor where you needed a control panel.

The most celebrated interaction pattern of the last two years — text that materializes word by word, as if the machine were thinking out loud — is, for a screen reader user, closer to noise than to language. Every token your model emits is a DOM mutation. Plug a naive aria-live region into that stream and the screen reader will try to announce each mutation as it lands, producing a stuttering, overlapping torrent that resets mid-sentence dozens of times per second. The feature that makes your product feel alive is the same feature that makes it unusable for the people who depend on assistive technology.

This is accessibility debt, and generative UIs accrue it faster than any interface pattern before them. The reason is structural: traditional web content is static and predictable, so you can reason about it once and ship. A generative interface changes on every interaction — one prompt returns a list, the next returns a table, the next streams 600 words of prose followed by a tool-call widget. There is no fixed DOM to audit, no stable tab order to verify, no single snapshot that represents "the page." The accessibility contract has to hold across an infinite space of generated outputs, and almost nobody is testing for that.

A user asks your shopping agent for "running shoes under $150 with good arch support." The model dutifully returns twelve options as a wall of bulleted text inside a single chat bubble that overflows the viewport. The user scrolls, loses their place, and types "show me only Asics" — at which point your agent re-runs the entire search instead of filtering the result set it already has. Three turns later, the user is inventing a query language one prompt at a time, and your product feels like a command line wearing a chat-bubble costume.

This is the failure mode I keep watching teams ship. They built a chat product on top of what users actually wanted to be a faceted-search product. The model is fine. The retrieval is fine. The UI is the problem, and it's the wrong shape for the task.

The shortest way I can put it: chat is an input modality, not an output one. The agent's job is to translate user intent into a structured query. The moment the result set is more than three items, the right answer is to render UI, not to keep talking.

The button label that shipped to your users last Tuesday was never seen by a copywriter, never reviewed in Figma, never QA'd, and didn't exist until inference time. It was generated by a model that decided, mid-conversation, that the right way to collect a shipping address was a six-field form rendered inline rather than three more turns of prose. The form worked. The label was fine. Nobody on the team can tell you which model run produced it, because the trace was rotated out of hot storage and the eval suite tests text outputs, not component graphs.

This is generative UI in production: the model is no longer just a text generator that occasionally invokes a tool. It is a UI compiler whose output is a component tree, and the design system is now a contract the model is constrained to rather than a guideline a human loosely follows. The shift breaks an entire stack of assumptions — QA against static specs, accessibility audits of fixed layouts, copy review of finalized strings, design-system adherence checks at build time — and most teams ship the feature before they have replaced any of them.