August 17, 2023
The conversational interface — a single text box into which you type plain language and receive a plain-language reply — arrived in 2023 with a claim attached: that it had finally escaped the clutter of buttons, menus, and panels that Jef Raskin spent his career criticizing. There is nothing to learn, the argument goes. You just say what you want. The interface has dissolved into language itself.
It is an appealing claim, and it is partly true. But anyone who has read Raskin carefully will recognize the shape of the problem hiding inside it. A conversation is a mode. The same input produces different results depending on what came before it, and what came before it is, to a large extent, invisible to the user. Raskin defined a mode as precisely this: a state in which an action’s meaning depends on context the user cannot reliably see. By that definition, the modeless-looking chat box is one of the most thoroughly modal interfaces ever shipped.
The Look of Modelessness
It is worth granting what the conversational interface gets right, because the critique only matters against a real advance.
The chat box does remove a great deal of visible structure. There is no toolbar to scan, no menu hierarchy to traverse, no settings panel to misconfigure. In Raskin’s terms, it eliminates an enormous number of widgets — each of which carried a search cost and a learning cost. A person who can type a sentence can begin using it immediately, with none of the habituation a conventional application demands. That is a genuine reduction in the visible-interface burden Raskin objected to, and it should be acknowledged as one.
The trouble is that Raskin’s objection to modes was never about visible clutter. It was about hidden state. And the conversational interface, having removed the visible clutter, has quietly maximized the hidden state.
The Conversation as Hidden State
When you type a question into a chat interface, the response depends not only on the words you typed but on everything earlier in the conversation. A request that would produce one answer at the start of a session produces a different answer later, because the accumulated exchange has shifted what the system treats as relevant. The system is, in the most literal sense, in a different state than it was a few messages ago — and you acted on it as though it were not.
This is the canonical mode error, transposed to a new medium. With Caps Lock, the hidden state is a single bit and the system tries, inadequately, to expose it with a keyboard light. With a conversation, the hidden state is the entire accumulated history, weighted in ways the user cannot inspect, and there is no light at all. You cannot see what the system is carrying forward, what it has inferred about your intent, or which earlier remark is silently shaping the current reply.
Raskin’s diagnosis applies without modification. The user holds a belief about the system’s state — usually the belief that they are starting fresh, or that the system understood their last message the way they meant it. The belief turns out to be false. The system responds faithfully to its actual state, which differs from the state the user imagined. The user is blamed, or blames themselves, for a failure that is properly the interface’s.
Why It Is Worse Than a Toggle
A defender might say that all interfaces carry some state and that the conversation is no different in kind from a document with unsaved changes or a tool with a selected color. The difference is one of legibility, and it is large.
A selected color is shown. Unsaved changes are usually indicated. These are states the interface at least attempts to expose, however imperfectly. The conversational interface’s state is, by construction, not exposed — it lives in an accumulated history that the system processes but does not render in any form the user can audit. You can scroll back and reread your own messages, but that is not the same as seeing the state the system actually holds, because the system’s state is an interpretation of that history, not the history itself.
There is a second aggravating factor that Raskin would have flagged immediately: the interface invites the user to assume more shared understanding than exists. A conversation in plain language carries the conventions of human conversation, including the assumption that the other party remembers and understood what was said. When the system’s actual retention and interpretation diverge from that assumption — as they routinely do — the user is misled not by a deliberate deception but by the very naturalness of the medium. The more human the interface feels, the more confidently the user mispredicts its state.
What Raskin’s Principles Would Demand
Raskin’s response to a mode was never simply to condemn it. He demanded that state be made visible and, where possible, that the burden of tracking it be removed from the user. Applied here, his principles suggest concrete directions rather than a verdict of failure.
A conversational interface built on Raskin’s premises would make its state inspectable: it would let the user see, in some honest form, what it is carrying forward and what it believes the current intent to be. It would make resetting that state trivial and obvious, so that the user could reliably return to a known starting point rather than guessing whether the slate is clean. And it would avoid leaning on the conversational metaphor to imply an understanding it does not possess, since that implication is the mechanism by which the user is led to mispredict.
None of this requires abandoning the conversational form. It requires treating the conversation as the mode it is, and applying to it the same discipline Raskin demanded of every other mode: expose the state, or remove it.
The Familiar Shape of a New Problem
The most useful thing about reading the conversational interface through Raskin is that it dissolves the sense that this is an unprecedented design situation. It is not. It is a very old problem wearing new clothes. The industry built an interface that looks modeless, congratulated itself on having escaped the burdens of conventional UI, and in doing so reintroduced the oldest burden of all — the hidden state that the user must track and cannot see — in a form more concealed than before.
Raskin would not have been impressed by the disappearance of the toolbar. He would have asked the question he always asked: can the user reliably predict what their action will do? For the conversational interface of 2023, the honest answer is often no — and the reason is the one he named decades ago. The clutter is gone. The mode is not.
Related: