← Writing

Language is not
an interface.

Every generation of computing tries to turn human speech into a steering wheel. Generative AI made intent computable, but a chat box is still an engineering shortcut. Why talking to software is usually the slowest way to work, what breaks when you banish visual controls, and where the real paradigm lands.

In mid-2023, usability pioneer Jakob Nielsen declared that artificial intelligence was the first new user interface paradigm in sixty years.1 His framework was tidy: first came batch processing, where you fed punch cards to a mainframe; then command-based interaction and direct manipulation, where you clicked menus and dragged files; and finally intent-based outcome specification, where you describe what you want and let the computer figure out how to do it.

Nielsen was right about the shift in mechanics. We moved from procedural execution to intent specification.

Where the industry lost its mind was assuming that because intent is expressed in words, the interface must be a conversation.

For the past three years, product teams have slapped a chat window onto every piece of software in existence. Spreadsheets, design tools, code editors, and operating systems were suddenly expected to run like an awkward text exchange with a colleague. Startups tried to sell screenless pins and voice pendants, promising that visual interfaces were obsolete relics of a less intelligent era. Almost all of those devices failed on contact with actual humans.

The chat box is not the future of computing. It is a transitional compromise, and recognizing why it fails reveals what will actually replace it.

01 The developer's shortcut

The reason every AI feature looks like a chat window is simple: large language models take text in and spit text out.

A prompt box is the fastest thing a developer can wire up to an API endpoint on a Friday afternoon. It requires no design system, no layout logic, no state synchronization, and no accessibility audit. You drop in an input field, attach an auto-scrolling message list, and declare the application modernized.

Designer Amelia Wattenberger made this point persuasively in 2023: chatbots are a developer convenience masquerading as user experience.2

Good interface design is about doing the heavy lifting for the user. It organizes complexity into recognizable shapes, hides irrelevant choices, and presents clear paths forward.

A blank text prompt does the exact opposite. It abdicates all responsibility. It takes the hardest problem in software design, which is deciding what the user needs to see right now, and hands it straight back to the user. You are not given a tool; you are given an essay assignment.

02 The affordance crisis

In The Design of Everyday Things, Don Norman laid out the foundational rules of usability.3 Chief among them are affordances and signifiers: visual clues that tell you what an object can do, and how you are supposed to interact with it.

A door handle signifies pulling. A flat plate signifies pushing. A button on a screen looks pressable. A slider shows its track, its current value, and its upper and lower boundaries. If an action is unavailable, a well-designed system grays it out so you do not waste time attempting it.

A blank chat prompt has zero signifiers.

It offers no clues about what the system knows, what tools it has access to, or what constraints it operates under. It does not tell you if it can read your local filesystem, whether it understands a specific API, or if your prompt is twenty words away from blowing past its context window.

This creates what Norman called the Gulf of Execution. You sit in front of an empty text box, forced to guess what combination of vocabulary and framing will trigger the outcome you want without producing hallucinations. That guessing game has a polite industry name: prompt engineering. In any other product category, having to guess the magic words to make a tool work is called a defective interface.

Ben Shneiderman warned about this dynamic in the late 1990s when debating the proponents of software agents.4 Shneiderman pointed out that human beings thrive on recognition, not recall. Choosing an option from a visible list takes almost no working memory. Having to formulate a precise sentence from scratch consumes the exact cognitive bandwidth you need to solve the underlying problem.

03 You cannot steer with adjectives

The second failure of natural language is information bandwidth.

Speech and writing are serial, one-dimensional streams. You produce words one by one, and you process them one by one.

Human vision is parallel and multi-dimensional. Your eyes and visual cortex can take in a two-dimensional grid of thirty numbers, spot a negative trend, and notice an outlier in two hundred milliseconds. Forcing an AI to serialize those thirty numbers into three polite paragraphs of prose turns an instantaneous visual scan into sixty seconds of forced reading.

Even worse is the problem of continuous control.

Most real-world work is spatial and continuous, not symbolic. You adjust a photographic crop by dragging an edge. You balance an audio track by nudging a fader while listening to the mix. You steer a 3D camera by moving a mouse through space. You scrub a video timeline with a jog wheel.

You cannot steer with adjectives. Typing "make the left margin slightly wider, no, not that wide, just a touch narrower and shift the blue accent closer to slate" is an exercise in pure frustration. It turns a ten-millisecond muscular adjustment into a thirty-second conversational negotiation.

Language is great for contracts, stories, and declarations of intent. It is a miserable way to manipulate continuous state.

04 What keeps language from taking over

If natural language has so many flaws, why is it considered a paradigm shift at all? Because inside its proper domain, it does things that graphical interfaces never could.

Language solves the cold-start problem. When you face an empty project, typing "scaffold a Rust service with PostgreSQL and JWT authentication" saves two hours of clicking through menus and copying boilerplate.

Language also bypasses deep software hierarchies. In applications with fifteen hundred commands buried under nested menus, such as CAD packages, spreadsheets, or cloud consoles, typing "highlight all transactions over five thousand pounds from unverified vendors" is vastly faster than constructing a five-stage filter manually.

The reason natural language cannot become ubiquitous right now comes down to three stubborn technical realities:

First, non-determinism. Human interfaces require predictability. If pressing a button labeled "Save" sometimes saves the file, sometimes renames it, and occasionally deletes the previous paragraph depending on the temperature setting of a model, nobody will trust it with serious work.

Second, the cost of course correction. In a direct manipulation interface, undoing an error is instantaneous. You press a key combination, and the system reverts to its exact prior state. In a chat interface, undo is an argument. You type "undo the last change," and the model apologizes, modifies three other things you wanted to keep, and introduces a subtle new bug. Correcting conversational output is often more exhausting than doing the task by hand.

Third, invisible state. A chat history is an atrocious data structure for tracking system state. As a conversation scrolls off the top of the screen, the user loses track of what constraints are active, what variables have changed, and what context has fallen out of the model's memory.

05 The real shape of the future

The future of software is not an operating system made of speech bubbles.

The realization that thinkers like Maggie Appleton and interface researchers at labs like Ink & Switch have pointed toward is that language and direct manipulation are complementary, not competing.5

Language is the ultimate summoner. Direct manipulation is the ultimate refiner.

The emerging paradigm is what many now call Generative UI. You do not talk to an assistant that speaks back in paragraphs. You use language to describe an intent, and the machine constructs an ephemeral, tailored graphical interface in milliseconds.

You tell the system: "I need to review our server costs across Europe for the last six months."

A bad AI gives you four bullet points and an apology for the delay.

A real interface generates a custom, interactive dashboard on the fly. It renders a timeline scrubber, three toggle filters for instance types, and an interactive cost curve. You do not type your follow-up questions; you drag the date slider with your mouse, click the spike on Tuesday, and check the box to isolate database traffic.

When you are done, the temporary interface dissolves.

Language sets the intention and brings the right tools into existence. Hands and eyes do the work.

We do not need software that mimics a talkative person. We need software that understands what we want, builds the right control panel on the spot, and then gets out of the way so we can work.