What should an interface remember?

An interface can remember the language we use, our preferences, where we left off in a task, what we have previously looked up, or even the context of earlier conversations.

That memory changes the experience.

We no longer interact solely with what appears on the screen at that moment. Part of our relationship with the product is also shaped by what happened before and by the system’s ability to use that context when we return.

When well designed, this memory avoids repetition, reduces friction and makes the product more useful. But it also raises a question that is not merely technical:

What should an interface remember?

Because being able to retain information does not mean it always makes sense to do so. The important decision is not how much a system can remember, but what deserves to become memory and why.

Remembering is not about accumulating data

Storing information and remembering are not exactly the same thing.

A product can record searches, clicks, purchases, locations or past actions without any of this translating into a more useful experience. Having more data does not necessarily mean knowing the user better.

Memory begins to have value when something from the past meaningfully changes what happens in the present. Remembering the chosen language, restoring an unfinished task or retaining the context of a conversation can avoid unnecessary steps and make the interaction more coherent.

The difference lies in the purpose.

An interface does not need to retain everything that happens. It needs to identify what information can provide context, reduce friction or help the user continue without having to start again.

That is why designing memory is not about deciding how much to store, but about deciding what information deserves to keep influencing the experience.

Not everything deserves to become memory

Not all information that may be useful at a particular moment should be retained permanently.

Some preferences do make sense to retain, such as language, a usual setting or certain recurring choices. There is also contextual information that can be useful while a task remains open: the point at which we left a process, a recent search or the content needed to continue a conversation.

But other data quickly lose their value.

A passing interest should not automatically become a stable preference. An isolated action does not always define a habit. And an inference based on behaviour may simply be wrong.

Here lies one of the main risks of digital memory: confusing something that happened once with something that remains relevant.

Designing good memory therefore means distinguishing between what should be retained, what should be temporary and what perhaps should not be remembered at all. Sometimes, remembering less makes it possible to understand better.

Memory can be wrong too

Remembering does not guarantee getting it right.

People change their preferences, jobs, routines or priorities. What was relevant yesterday may no longer be so, and a one-off decision may end up being interpreted as a stable characteristic.

Moreover, not all memory comes from something the user has explicitly said. Often, the system infers interests, habits or intentions from behaviour, and these inferences can also be wrong.

That is why useful memory should not be rigid. It must be able to be updated, corrected and, when it no longer adds value, disappear.

The problem is not that an interface gets things wrong from time to time, but that it continues to act as though an incorrect memory were still true.

If the system remembers, the user should know

An interface’s memory should not function as an invisible layer that changes the experience without explanation.

If a recommendation, response or action depends on something the system remembers, the user should be able to understand where that decision comes from. There is no need to show technical logs or turn every interaction into an explanation, but there should be enough cues for personalisation to be understandable.

It is also important for control to appear close to the moment when that memory takes effect. If a preference is shaping a search, recommendation or response, being able to correct it there is usually more useful than requiring the user to find it in a settings section.

In this context, transparency is not about showing everything the system knows, but about making visible when a memory is influencing the experience and allowing the user to act on it.

Because useful memory should not only remember well. It should also make clear that it is remembering.

Conclusion

The quality of an experience does not depend on how much a system knows about us.

It depends on whether it knows how to use that knowledge well.

Remembering a useful preference, maintaining the right context or preventing us from having to repeat a decision can clearly improve an interaction. But accumulating information without judgement can do exactly the opposite: introduce noise, create errors or turn personalisation into something difficult to understand and control.

Designing memory means making decisions about what to remember, for how long and when to stop doing so.

This judgement will become increasingly important as products become able to retain more context about our actions, habits and decisions.

Because a good interface should not aspire to remember everything. It should aspire to remember better.

What criteria are you using to decide what an interface should remember and what it should forget?