Principles

What does it mean for an interface to think?

A button usually knows one thing: what to do when you click it.

Click Save, and it saves. Click Delete, and it deletes. You figure out what needs to happen, find the right control, and tell the software to do it. We’ve built a lot of very good software around that arrangement.

But what happens when the interface can make sense of what you’re doing and who you are?

A button could offer a different action depending on what you’ve selected, what you’re working toward, or what just changed. A text field could help finish a thought. A document could leave a note beside a passage because it matters to the question you’re trying to answer.

The interface itself starts making judgments about what would be useful, for you, in that moment. Its controls, suggestions, and content can adapt as your intent becomes clearer. That’s what I mean by an interface that thinks.

Not every part of an interface needs to think. It’s important that some parts don’t. Muscle memory still matters. Save should still save. Undo should still undo. You shouldn’t have to wonder whether a familiar control has decided to do something different today. Those predictable parts give you the confidence to act without checking every step.

But interfaces that do think, they can be powerful in ways that generations of interfaces have not been. They can bring a capability into view when it becomes useful, even if you didn’t know to look for it. A product can become more capable without asking you to learn a new workflow for every feature.

They’re already here

Gmail’s Smart Compose is a small example of this already working. As you write, a suggestion appears ahead of your cursor. Press Tab to accept it, or keep typing your own words.

In the above example, the writer is asking someone to a movie. Gmail offers the end of the question, right where the next words belong. You can evaluate the suggestion while reading the sentence you’re already writing. It’s subtle, helpful, and barely noticeable.

The text field has become an active participant. It has something to offer, personalized to you, and accepting that offer takes almost no effort.

There are four qualities worth pulling out of that interaction. They’re the principles I’ll use to guide this series.

1 — Timely

An interface that thinks is one that is timely about when it offers its help. It shows up where your attention already is, while there’s still a useful decision to make.

A good suggestion delivered after you’ve moved on is just another interruption.

2 — Proactive

An interface that thinks is one that is proactive about what you might need next, anticipating what you’d already want to do. It uses what you’re actively doing and what it knows about you to offer a useful next step before you have to ask.

3 — Personalized

An interface that thinks is one that is personalized to how you work and who you are in the very moment. Perhaps even how you’re feeling. It takes your preferences, habits, and current goal into account when deciding what to offer.

4 — Collaborative

An interface that thinks is one that is collaborative in how it helps you get there. It contributes something you can accept, change, or ignore while keeping you in control. Otherwise, it’s not an interface, it’s an autonomous action done without your involvement.

How it maps

Smart Compose brings all four together in a few words of suggested text.

It’s timely because the help appears at the cursor, as the sentence is taking shape. That’s when a few suggested words can save you effort. After you’ve written them, the opportunity has passed.

It’s proactive because writing is enough to invite a suggestion. You don’t have to stop composing and ask for help finishing the sentence.

It’s personalized when personalization is enabled: Google tailors suggestions to the way you normally write. The ambition is to help you sound like yourself. Without that setting, the suggestions are generic.

It’s collaborative because the suggestion remains a proposal. Tab accepts it. Continuing to write is enough to take the sentence somewhere else. There’s no separate negotiation with the software.

Of course, it guesses wrong. But the interaction makes a wrong guess easy to move past. That matters just as much as getting the suggestion right.

There are other traits that make Smart Compose so good. It’s forgiving, it’s ignorable, it uses a familiar pattern of autocomplete. I considered those as principles as well but they felt too restricting to the domain as a whole.

So much more to explore

Rooted in these principles, this series will explore how interfaces that think can help us write, read, create, and work with the objects around us. Through prototypes in text, hardware, and imagery, I’ll test where that intelligence helps and where a familiar control already does the job.