Blog

We taught computers to look like our world. Now we’re teaching them to handle the work so we can leave the screens and get back to living.

In the summer of 2024, I made a prediction: user interfaces as we know them were going to go away.

The screens. The menus. The workflows that require us to learn how an application thinks before we can accomplish anything.

As we head toward 2027, I’m doubling down.

My reasoning goes deeper than AI getting better at answering questions. It comes from a pattern running through interface design history: we make technology easier to use by connecting it to something people already understand.

First, we gave people familiar objects. Now, we can give them a familiar way to ask for help.

We built software out of familiar things

Desktop. Documents. Folders. Trash.

The vocabulary of computing borrows from the physical world. So do the interactions: adding products to a shopping cart, marking dates on a calendar, highlighting text with a digital marker.

These metaphors let people bring existing knowledge into an unfamiliar environment.

Even as interfaces became less visually literal, those references remained. Google’s original Material Design drew on paper, ink, light, and surfaces. Touch interfaces let us manipulate content more directly with our fingers.

The useful part was always the understanding people brought with them.

Now consider another familiar way we accomplish things: we ask someone to help.

We explain what we want. Provide constraints. Answer a question. Let them handle the task and come back when they need us.

That’s the interaction I believe software is moving toward.

We moved the store onto a screen. We’re still walking the aisles.

A grocery app makes shopping accessible from the couch. But we still do much of the coordination.

Plan meals. Check the pantry. Search for ingredients. Compare quantities. Find substitutes. Check the total. Remove something because we went over budget.

Now imagine saying:

“Plan five easy dinners for two. Use my pantry list, keep the groceries under $100 including fees, and ask before buying.”

The assistant responds:

“I’ve picked ingredients for chicken tacos, veggie stir-fry, spaghetti, salmon bowls, and lentil soup for $94. Do those sound good?”

I might ask it to swap a meal or show me the cart. But I no longer need to operate every step of the workflow.

I describe the job. The software coordinates the work.

When we ask someone to pick up groceries, we don’t dictate every turn through the store. We communicate the outcome and the conditions that matter.

Software can follow that same model.

The interface becomes a conversation, with depth on demand

People use applications to get something done. Learning the application is part of the cost.

Designers reduce that cost through clearer labels, simpler navigation, and shorter flows. But reliable delegation raises a bigger question:

Why is the person navigating this workflow at all?

I could request groceries while checking the kitchen, with my hands occupied and my laptop closed. Chat offers the same ability when speaking is inconvenient or inaccessible.

The response should be equally straightforward: what happened, what needs my attention, and what comes next.

That’s what I mean by a TL;DR interface.

Then let me go deeper. Show me the products. Explain a recommendation. Compare the options. Break down the cost.

Images, charts, and other visuals still matter. They appear when they help me understand or decide, without requiring me to navigate an entire application to reach them.

The software should come back when it needs me

Delegation also means I shouldn’t have to keep checking for updates.

Open the app. Refresh the page. Check the status. Remember to come back later.

Instead, the assistant should bring a relevant exception to my attention:

“Your delivery slot is no longer available. The next one is 6–7 p.m. Would you like that instead?”

People need control over what warrants an interruption and how it arrives. An assistant that constantly demands attention hasn’t relieved the burden.

Successful delegation lets us step away.

The interface can shrink when the system earns our trust

Conversation alone won’t deliver this future.

The system has to respect budgets, preferences, permissions, and constraints. It has to recognize failures and ask for help when necessary.

There will also be times when browsing or direct manipulation is easier, more useful, or simply enjoyable.

But I believe far less routine coordination will require screens once software can reliably handle it.

That changes the design challenge. We’ll need to design how people express intent, how systems clarify uncertainty, how results are explained, and when an assistant should interrupt.

We used familiar objects to help people understand unfamiliar machines. Now we can build around another familiar behavior: asking for what we need.

That was my prediction in 2024.

The future I’m betting on is one where I can close my laptop, put down my phone, and trust the software to come back when it has a result or needs my judgment.

Photo by Christin Hume on Unsplash.