It’s Time to Stop Learning Software

Nina [Designnina]

12 min read

·

Sep 24, 2026

--

Listen

Share

What if the next interface adapted to the way we think, work and build habits — instead of asking us to learn another system?

Press enter or click to view image in full size

We still learn software the way we learn household appliances: what to press, where to look, and what sequence to repeat next time.

Except software has multiplied to the point where a significant part of digital literacy is no longer about doing the work, but is about learning how to get to the work.

At this stage also AI makes this arrangement look increasingly strange — if a machine can already understand the task, why should a person still have to learn its interface first? After all, learning a new product always requires a huge amount of effort and time.

I’m less interested in whether the next interface will be voice-based, text-based or spatial. The more interesting question is what happens if we reverse the direction of adaptation: instead of the human learning the tool, the tool starts learning the human.

First we learn the software and then we do the work

Let’s suppose I need to write a document — the task itself is easy: gather my thoughts, structure them, add sources, edit the text. Buuuut before I can begin, I have to choose where to do it! — Word, Google Docs, Pages, Notion and so on and on and on. Each comes with its own menus, shortcuts, limitations and logic.

For images, there is Photoshop, for interface design, it’s Figma, for data — Excel, for video, there is always another product with another grammar. We accept this as normal because, for the most part, we have never known anything else.

Just the easiest example: replace your coffee machine and even the simple act of “making coffee” becomes a small investigation for a few seconds: where does the cup go? Which button do I press? What does that blinking symbol mean? A week later, you no longer think about the interface. Because your hand just knows.

So, the software works the same way, only at a much larger scale. Good UX shortens the period of confusion. It makes functions easier to find, reduces unnecessary steps and gives clear feedback, but the underlying arrangement stays the same. First, a product exists with its own internal logic. Then a person arrives and learns how to work inside it.

What if we changed the arrangement itself?

Not: task → software → learn the software → do the work

But: task → system understands the context → creates the working environment → do the work

Here what we have: I need to write a document, so a space for working with text appears. I need sources, so tools for working with sources appear. I move on to the data, and the environment changes. I turn those findings into a presentation, and a different set of tools becomes available.

Here, I no longer have to begin with the question: “Which application should I open?” In this model, the interface does not exist because a company once decided to build an app — it exists because a person has a task.

Press enter or click to view image in full size

Not one interface for everyone, but an interface for how someone thinks

Personalisation today is still fairly superficial. We can change the theme, rearrange panels, set shortcuts, increase the text size, sometimes choose between simple and advanced modes, but we are still customising one pre-designed structure. People, meanwhile, work in completely different ways.

One person needs to spread everything out in front of them before they can make sense of it. Another finds excess information distracting and only wants to see the next step. Some people think in diagrams. Others think in language. Someone else immediately builds a table because rows and columns help them see the structure of the problem.

This is not simply a matter of taste — it is part of how someone solves a problem. That’s why I am much more interested in an interface that learns not only my settings, but my behaviour: what do I keep opening? What do I close first? When do I need a visual model, and when is a single command enough? Which actions have I been performing in exactly the same way for years?

At that point, personalisation stops meaning “arrange the panels however you like.” The system gradually learns how to present the work in a way that makes sense to ME. And that leads to a much larger consequence.

Photoshop is not a skill

We often say: “I know Photoshop.” Or: “I’m very good at Excel.” But knowing Photoshop is not the same as knowing how to work with images. Excel is not analytical thinking. Figma also isn’t the design itself.

If Photoshop disappeared tomorrow, a designer shouldn’t lose their understanding of composition, light and colour along with it, right? If Excel disappeared, an analyst wouldn’t suddenly lose the ability to recognise patterns in data.

Software is the language through which a capability currently talks to a computer.

We have simply used some of these languages for so long that we have started confusing knowledge of the syntax with knowledge of the subject.

Education could change here too — a huge amount of training still teaches sequences: open this menu, click here, select this mode. That works perfectly well while the interface remains stable. But there is a difference between someone who has memorised a recipe and someone who knows how to cook!!

The first person knows: 180 degrees, 25 minutes, this many grams. Change the oven, the ingredient or the portion size and the instruction begins to break. The second — understands what heat, time, fat, acidity and texture are doing. They can change the tools and still get the result.

Software may go through the same shift.

I think we may spend less time learning where a function lives, and more time learning why we need it in the first place.

Not how to build a graph, but when a graph actually helps us understand the data. Not how to turn on Auto Layout, but how a structure should behave when the content changes. Not how to create a mask, but how to separate an object so that the result still looks natural.

Professional knowledge starts moving out of the interface and back into the profession itself.

Press enter or click to view image in full size

But then why do we need an interface at all? Just tell the AI what to do!

This is the first obvious counterargument. If an AI-agent is smart enough, why move objects, build tables or press buttons at all? Just describe the result and let the machine produce it.

The problem is that this model assumes something very convenient: the person already knows what they want.

Most of the time, we don’t.

Imagine an empty room. You could say: “Arrange the furniture so it’s comfortable.” That sounds like a perfectly reasonable prompt. But what does “comfortable” mean in this room?

Sometimes you only discover the problem after moving the chair, stepping back towards the door and realising that now you have to walk around it every time you want to get to the window.

Until that moment, the problem did not exist in your description, because you discovered it by acting.

The same thing happens with data. I can ask a system to build a particular chart and only then notice an anomaly I did not know existed. I could not have included it in the original prompt because I did not yet know there was anything to ask about.

Thought does not always come first and action second. Sometimes action produces the thought. That is why I do not believe the computer of the future will collapse into an empty prompt box. Language works beautifully when the intention is already formed.

But humans do not think only in words. We compare, move things around, group them, try, go back, look again. An interface does not exist only so that a machine can receive a command, but also because a person needs it to understand the task itself.

Yes, an agent can execute a clearly formulated intention, but a good interface can help us form the one.

What about nodes?

There is another objection: haven’t we already created more flexible interfaces? We have node-based systems. Instead of digging through menus, they allow us to assemble a process from blocks and see the relationships between them.

Yes, and for many tasks, they are excellent. But nodes do not change the underlying problem. The human still has to learn the language of the system. First we learned menus, panels and commands. Now we learn nodes, ports, connections and the rules of the graph.

A visual language does not automatically become a human language simply because rectangles and lines have replaced lists of commands. A node editor still says: “Here is my language. Learn it.”

Here, I am interested in the reverse situation: the system can express the same underlying logic in different ways: for a specialist who naturally thinks in graphs, it shows nodes, for someone else, the same task may work better as a sequence, and a third person may need a table.

So, nodes do not disappear, they just simply stop pretending to be the next universal answer.

Press enter or click to view image in full size

Habit has value too

And here I run into a much stronger objection, or counterargument, or whatever. People become fast not only because they understand the task — they become fast because they become familiar with the tool.

An experienced Photoshop user does not search visually for every command. A driver does not look down to remember where the pedals are. A pianist does not calculate the coordinates of each key.

Repetition makes an action automatic — the golden rule of psychology. If the interface keeps changing, that automation disappears. The system may claim to be adapting to the user while forcing them to rediscover the brake pedal every morning.

I clearly understand that nobody wants that interface. So adaptation cannot mean constantly rearranging everything, of course sometimes the best adaptation is to leave something exactly where it is.

If a system genuinely learns a person, it must understand not only the task in front of them, but also their habits. It should know when an action has become automatic and when changing it would create more friction than it removes.

This is why I like the idea of a stable core with an adaptive periphery. Which means — what a person uses constantly stays in place, what the current task requires appears around it, what they never use does not have to occupy screen space for the next ten years simply because a product team once added the feature.

Today, my muscle memory belongs to Photoshop, Excel or Figma. When I move to another product, part of my speed stays behind in the habits and interfaces I learned there.

But what if the habit belonged not to the software anymore, but to me? Where instead of every new tool forcing me to relearn its architecture, my working environment could carry the patterns it already knows about me into the next task.

In my logical comprehension of the future interface is that the interface is not configured once. It grows with the user.

Then how do we share knowledge of the software?

This problem follows directly from the last one. Today, one designer can tell another: “Open Layers and set it to Multiply.”

Here the instruction works because both people are looking at roughly the same Photoshop. But what if interfaces become personal, my button may not be where yours is, yep? There may not even be a button… So how do we teach one another? How do we share knowledge?

I do not think the answer is to abandon standards. Without standards, we cannot drive safely, collaborate on documents or move data reliably between systems. But the standard can move from the surface to the meaning.

Instead of “press this button, separate the object from the background, create a pivot table, use Auto Layout, make sure the block keeps its structure when the text changes” — it’s gotta be a completely different level of professional conversation.

We are no longer transferring the coordinates of a button to each other — we are transferring the method, the logic and the expected result. The tool just translates that task into its own interface.

Actually, much of education still works in a similar way: give someone the correct sequence of steps, then test how accurately they can reproduce it. And it’s totally fine as long as the problem looks like the example. But, change the conditions slightly and a person can become lost, not because they lack knowledge, but because they were taught to follow a route rather than find their way without one.

Perhaps the problem of a shared language runs deeper than interfaces. We may need to spend less time teaching people to repeat instructions and more time teaching the principles that allow them to construct a solution again when the circumstances change? But that is a much laaaaarger conversation for later.

The point is that sharing knowledge does not disappear. It simply depends less on a particular toolbar and more on understanding what we are actually trying to achieve.

We stop passing on instructions for interacting with interfaces, and we start passing on ways of thinking.

Press enter or click to view image in full size

And what about business? Where does the economic value go?

Up to this point, it is easy to discuss interfaces as though this were only a design problem. But as soon as the interface stops belonging to the application I was reasoning about, a more uncomfortable question appeared in my head: who owns the product?

Today, the boundaries are easy to see: here is Photoshop, here is Excel, and here is an airline’s service — each product has its own interface, brand and relationship with the user.

Let’s take a simple task like organising a trip. Today I might open my calendar, a flight site, maps, a hotel service, my banking app and my documents. Bah bah bah bah — lots of actions and lots of apps. Five or six companies show me all different interfaces.

But my initial task isn’t to visit five applications. What literally I want to do is to organise a trip. If the working environment is built around the task, I could see one space.

But in real life is one company provides the flights, another provides maps, a third handles payments and a fourth provides the calendar.

For the user, it is one process even though many services are operating underneath it. And that changes the product itself.

A company may no longer need to sell an entire application. It could provide the best function for one part of the job: calculation, translation, search, payment, image processing, document verification.

It sounds almost ideal until you ask the next question: who chooses the company?

Imagine having a personal shopper whom you no longer need to instruct because they know your habits perfectly. So, they choose the shop, the brand and the price themselves. Sounds very convenient, actually where we go to.

But now the shops are no longer competing primarily for your attention. They are competing for the shopper’s decision. The same thing is happening with AI.

If one company knows my habits, holds my context, understands the task, creates my working environment and decides which external service to call, it has far more power than the maker of a single application ever had.

In my mind is that we did not eliminate the monopoly — we’ve taken it to a new level. Today, companies compete to make me open their app, and alreadt tomorrow, they may compete to make my AI choose their function.

There is another possible model: an environment where different providers operate through common rules, where users can take their context with them, and where the system explains why it chose one service over another.

Which model wins is another question, but the economic consequence is already interesting: if the interface separates from the application, the very unit of the software product may change.

So who does the interface finally belong to?

I started with a question about what the interface of the future might look like. The further I go with the idea, the less interested I become in its appearance. Buttons do not have to disappear, neither do nodes, text, voice, gestures and familiar panels can all coexist perfectly well. But something else has to change.

Today, a person enters someone else’s system and gradually learns its language. Because the interface belongs to the software, and our habits form inside it.

I am thinking about the opposite model, where a system knows my habits. It preserves what I have already learned, and it changes only what gets in the way of the new task. It brings in the tools I need when I actually need them.

In that model, the interface does not disappear, it just stops being the facade of a single application.

And, at the end, this is probably the idea I find most interesting now: what if the interface of the future belonged not to the software, but to the person using it?

Where would you draw the line? What should an interface be allowed to change for the individual, and what should remain the same for everyone?

Written by Nina Hadfield ✦ Translation and editing assistance from GPT-5.6 Sol {ChatGPT). Illustrations generated based on ideas.

Stay Connected: X | designnina.com