Bridging the Hard
and the Soft.

Machines like things that are exact. Every input has a defined output. Every branch eventually resolves into a path. Beneath every beautiful interface lives a world of booleans, indexes, packets, and deterministic logic.

Humans, on the other hand, are wonderfully inconvenient. We change our minds halfway through a sentence. We forget what we were looking for. We search for "that movie with the sad robot," unable to remember the title but convinced we'll know it when we see it. We rarely express exactly what we mean, yet we somehow understand one another anyway.

Design has always lived between these two materials.

Its job was never simply to make software beautiful. It was to translate — to build a bridge between the rigid certainty of machines and the soft ambiguity of people.

For decades, that bridge leaned heavily toward the machine. We learned its language. We memorized keyboard shortcuts. We filled forms one field at a time. We learned that a button meant action, a checkbox meant state, and a menu meant navigation. The computer wasn't particularly interested in understanding us. It expected us to understand it.

And, eventually, we did.

Not physically, of course. They remain as deterministic underneath as ever. Every response from an LLM is still the product of mathematics unfolding exactly as intended.

But at the surface, something changed. Instead of asking us to conform, they began adapting to us. We could speak naturally. We could ramble. We could start with half an idea and discover the other half while talking. For the first time, it felt less like operating software and more like collaborating with it.

That shift has sparked a familiar prediction: perhaps interfaces disappear altogether. Perhaps every application becomes a chatbot. I don't think that's where we're headed.

Because conversations aren't replacements for interfaces. They're another material.

And like every material, they're wonderful at some things and terrible at others.

Nature has been solving this exact problem for millions of years. How do you connect something rigid to something soft?

The obvious answer is to pick one. Make everything rigid. Or make everything flexible. Nature almost never does either. Instead, it builds seams.

Once you start looking for this pattern, it appears everywhere. Bones wrapped in muscle. Trees with rigid trunks and flexible branches. Cells whose membranes constantly change shape while their internal scaffolding keeps everything from collapsing. Even continents — massive tectonic plates drifting across a softer mantle, reshaping the planet over millions of years.

Nature rarely solves problems by choosing between hard and soft. It solves them by carefully deciding where each belongs.

Until recently, interfaces were built from certainty. Buttons always behaved the same way. Forms always expected the same inputs. Menus always contained predefined actions. There was comfort in that rigidity.

Predictability is valuable — especially when the stakes are high. Imagine wiring money. Filing taxes. Scheduling surgery. You don't want an interface that's feeling particularly creative that day. You want consistency. You want precision. You want certainty.

Hard interfaces earn trust because they behave exactly as expected.

But certainty has a cost. Every edge case must be anticipated. Every workflow must be designed in advance. Every unexpected need becomes another menu item. Another dialog. Another settings page. Eventually the interface begins to resemble a filing cabinet rather than a conversation.

Language models introduce an entirely different material. Instead of defining every possible interaction ahead of time, they improvise. They compress enormous amounts of knowledge into something fluid. Instead of asking us to find the right menu, they infer intent. Instead of exposing every feature equally, they surface what's relevant. Instead of saying "invalid input," they ask what we meant.

That softness feels almost magical. Until it doesn't.

Because softness has its own failure modes. A completely conversational interface can be strangely exhausting. Blank pages ask us to invent our own structure. Open-ended prompts demand decisions before we've even begun. Without boundaries, every task starts from zero.

A material that bends everywhere offers nowhere to stand.

Rather than replacing buttons with conversations, conversations begin connecting buttons. Rather than replacing structure, intelligence helps us move through it.

Think about opening your calendar. Today's calendars are collections of rigid components — events, dates, time slots, invitations. Each works beautifully on its own, but they rarely understand one another.

Imagine reading an email about next Tuesday's meeting. Instead of asking you to switch applications, search your calendar, locate the event, open the agenda, and find the related document, the interface quietly begins weaving those pieces together. The meeting appears beside the email. The design document opens automatically. Previous notes surface before you remember looking for them.

Nothing disappeared. The intelligence lives between them.

Like cartilage. Not replacing the bones — connecting them.

This way of thinking scales surprisingly well. At the smallest level, language models can generate content — words, images, summaries, suggestions. One level higher, they can assemble interface primitives: buttons, filters, input fields, menus that appear only when they're useful. Higher still, they begin composing entire interface blocks — lists, cards, dashboards, workspaces that adapt around the task instead of remaining frozen. And eventually, they influence flow itself: not deciding where everything goes forever, simply helping different pieces find each other.

The closer we move toward people, the more flexibility we allow. The closer we move toward data, the more certainty we preserve.

The interface becomes a gradient rather than a boundary.

Nature uses gradients as often as it uses segments. Your skeleton doesn't suddenly become skin. Between bone and air lies an astonishing sequence of transitions:

Bone.Periosteum.Tendon.Muscle.Fascia.Fat.Skin.

Each layer slightly softer than the last. Each distributing force a little differently. Each preparing the next material for what comes after.

Good interfaces might evolve the same way. Not changing all at once — softening gradually. For a new user, software should probably remain fairly rigid. It should teach. Suggest. Constrain. It should have opinions. As familiarity grows, those opinions can loosen. The interface begins trusting the person because the person has demonstrated understanding.

Expert users rarely want the same software beginners need. Why should they receive identical interfaces?

The same principle applies to tasks. Some demand exploration; others demand certainty. Writing an essay benefits from ambiguity. Filing an expense report does not. Planning a holiday invites wandering. Booking a flight five minutes before boarding does not.

Our interfaces have traditionally treated these moments the same. Language models give us the opportunity to distinguish them — not by replacing everything with conversation, but by understanding when conversation is actually useful.

Relationships between people and systems. Between certainty and ambiguity. Between memory and discovery. The visible screen is merely the place where those relationships become tangible.

Design, then, isn't arranging pixels. It's deciding where rigidity creates confidence — and where softness creates possibility.

The excitement around AI sometimes makes it sound as though we've reached the end of interface design. If software understands language, why design anything at all?

But every new material in history has expanded architecture rather than eliminating it. Steel didn't eliminate buildings. Concrete didn't eliminate cities. Glass didn't eliminate walls. They simply allowed us to imagine new forms.

Language models feel similar. They're not replacing interfaces — they're expanding the vocabulary we use to build them. Buttons remain useful. Lists remain useful. Timelines remain useful. Maps remain useful. Conversations become another element in the designer's palette. Neither superior nor inferior. Simply different.