Which UI Patterns Will Not Survive Conversational AI

A conversational interface, in the form most teams now build them, is good at exactly one job. It takes a user’s loosely articulated intent, interprets it, and translates it into a structured action the system can perform. The user describes what they want. The system does it. The interface in between is a chat box, and the chat box has no buttons, no panels, no forms.

Anyone who has used these interfaces for real work for a few months can already tell which jobs they are good at and which they are not. The list is shorter than the discourse suggests in both directions. Conversational interfaces are not eating every interface, and they are not failing at every interface either. The boundary is specific, and the specific boundary is reshaping which UI patterns are worth investing in for the next decade.

The patterns whose job is now done by conversation

A surprisingly large share of modern UI patterns exist for one reason, which is that the underlying system needed structured input the user did not want to provide. The user wanted a flight from Toronto to Lisbon next April, returning a week later, in economy, with a window seat preference and one checked bag. The user did not want to fill in eight fields, three dropdowns, and two radio button groups to specify this. The form existed because the airline’s reservation system needed structured input. The user tolerated the form because it was the path to the flight.

A conversational layer over the same system collapses the form into a sentence. The user types or says the request, the model interprets it into the structured fields the reservation system needs, and the system returns flights. The form did not do anything for the user. The form did something for the system, and the user paid the price of doing the system’s work. A conversational interface unbundles the two.

This pattern repeats across most enterprise software, most internal tools, most multi-step search interfaces, and most configuration wizards. Each of these interfaces is a structured input collector wearing a UI’s clothing. The user did not want to perform the steps. The user wanted the result. A conversational layer skips the steps and produces the result, and the steps were never the value.

Designers have spent a decade making these patterns elegant. The patterns are still elegant. They are also, in many cases, no longer necessary. The work the designer poured into a multi-step filter for a complex catalogue is, in a conversational version, replaced by a single text field that does the same job in one turn.

What survives, and why

A different category of patterns survives the conversational shift, and the survival has a clear explanation. These patterns serve a job that is not “translate intent into action,” it is “let the user act directly on something.”

A drawing tool is not a structured input collector. The user is not describing a drawing they want the system to make. The user is making the drawing, with continuous visual feedback, in a tight loop between hand and screen. A conversational version of a drawing tool fails the moment the user wants to make a small adjustment, because the granularity of natural language is much coarser than the granularity of direct manipulation. The drawing tool survives.

A dashboard is not a structured input collector. The user is exploring data, comparing series, noticing anomalies, and forming hypotheses. The interface’s job is to make many things visible at once and let the user move between them. A conversational version that surfaces one fact at a time loses most of the value, because the user’s insight comes from holding several facts in view simultaneously and noticing relationships. The dashboard survives.

A product catalogue, for browsing rather than for purchasing a known item, is not a structured input collector. The user is window shopping, calibrating taste, recognising things they did not know they wanted. The interface’s job is to present visual richness and reward exploration. A conversational version that asks the user to articulate what they want misses the mode entirely, because the user does not yet know what they want. The catalogue survives.

A trust-calibration interface, like the screen that shows the user what an agent did before the user approves it, is not a structured input collector. The interface’s job is to let the user verify the system’s work, often by showing the work in a visual form the user can scan. A conversational version that summarises the work in prose is less trustworthy, because the user cannot scan the prose for anomalies the same way they can scan a list. The verification interface survives.

The shared property of the surviving patterns is that the user’s value comes from interacting with the visible state. The patterns that go are the ones where the value came from the result, and the visible state was overhead.

The wrinkle about the patterns in between

A non-trivial set of patterns sits in the middle, with both modes adding value, and the right design probably blends them. A travel booking is the obvious example. The user can describe the trip in natural language and let the system propose options. The user then needs to compare options visually, see prices side by side, look at seat maps, and verify dates. The conversational layer does the search well. The graphical layer does the comparison well. The integration is the design challenge.

Most of the interesting design work for the next several years lives in this middle territory. The straightforward cases at either end have already been figured out. The middle cases require teams to think carefully about which jobs in a flow benefit from each mode, and how to hand off between them without making the user feel like they are switching tools.

The teams I have watched do this well share a discipline. They do not try to make either mode do the other mode’s job. The conversational layer is purely for intent capture and refinement. The graphical layer is purely for comparison, manipulation, and verification. The transitions between them are explicit and intentional, with the user always knowing which mode they are in and why. The teams that try to make one mode do everything end up with awkward interfaces that do neither well.

How design teams should be investing now

The honest read of which patterns are about to age out, and which are about to become more important, has clear implications for where design teams should be investing. Less effort in patterns that the conversational layer will absorb. More effort in patterns that benefit from direct manipulation, comparison, and verification. Even more effort in the transition design between conversational and graphical layers, which is the new craft surface.

This is not a directive to abandon the dying patterns immediately. The patterns will continue to ship for years, because the conversational layer is unevenly available and the graphical patterns are well-understood and reliable. The shift is in marginal investment. Where a team would have spent an extra sprint making a multi-step filter elegant, the team is better served spending the sprint making the comparison view that follows the filter excellent. The filter is going away. The comparison view is staying.

A team that ignores the shift will continue to produce well-crafted interfaces in patterns that are losing relevance, and will be slower to develop the craft for the patterns gaining relevance. A team that overcorrects will abandon mature patterns prematurely and ship awkward conversational replacements that frustrate users. The middle path is to invest a little more in what is becoming important and a little less in what is becoming obsolete, and to do this gradually rather than as a single repositioning.

The patterns that survive are the ones the user did not actually want to perform. They wanted the result. The interface stood between them and the result and refused to move.

The interfaces that did the moving will keep moving. The ones that did not will be replaced by an interface that does.