The Last Interface: Are We Going Backward?

Editorial Note by Jordan Wolf: I've recently been thinking about the impact of LLMs on product design and go-to-market strategy. One big question on every executive and strategist's mind is: Is this the end of GUI? Many related Go-to-Market strategy questions are circulating among teams as they assess the impact of a GUI-less world. I thought it would be interesting to visit this through the lens of a conversation with Steve Jobs, whom many in Tech credit to popularization of the GUI after discovering it during a tour of Xerox PARC in the 1970's.

Steve Jobs helped bring computing to the masses by making computers easier to see, understand, and manipulate. Now AI companies want us to communicate with computers through a chat box. Is that progress—or a step backward?

Imagine showing Steve Jobs the dominant AI interface of 2026.

A text box. A blinking cursor. A user typing a request. An AI responding with paragraphs of text.

Jobs might recognize something familiar.

Before the graphical user interface, interacting with computers often meant issuing commands and learning the language of the machine. The GUI changed that relationship. It gave people visible objects, recognizable metaphors, and the ability to manipulate things directly. Computing became less about memorizing instructions and more about interacting with what was in front of you.

Now, after decades of progress in graphical interfaces, we seem to be moving in the opposite direction.

Instead of opening an application and working with its interface, we're increasingly encouraged to describe what we want in a chat window and let an AI figure out the rest.

Why navigate a CRM when you can ask a question? Why build a spreadsheet when you can describe the analysis? Why learn an application when an AI can operate it for you?

The appeal is obvious. So is the contradiction.

We spent decades making computers less dependent on language and commands. Are we now making language and commands the primary way we interact with them again?

Perhaps this time is different. AI can understand natural language, interpret ambiguous requests, and coordinate actions across applications in ways that traditional command-line interfaces never could.

But there's a distinction worth examining: making computers easier to instruct isn't necessarily the same as making them easier to understand.

The GUI didn't merely provide a more pleasant way to issue commands. It changed what users could see, how they could explore, and how they could maintain control over their work.

If AI interfaces are to represent the next great leap in computing, they need to do more than let us talk to software.

They need to improve on what the GUI made possible—not quietly discard it.

The GUI was more than a better interface

The graphical user interface is sometimes described as a more intuitive alternative to the command line. That understates its significance.

A GUI changed the relationship between people and computers by making the system's capabilities visible and giving users ways to interact with them directly.

Consider the difference between being told that a file exists at a particular location and seeing that file in a folder. Or the difference between issuing a command to move an object and dragging it to where you want it.

In a graphical environment, users can discover capabilities by exploring. They can see the results of their actions, recognize relationships between objects, and develop an understanding of how the system works.

They don't have to memorize every possible command before they can begin.

The same principle extends far beyond the desktop. A spreadsheet makes relationships between numbers visible. A CRM pipeline shows the distribution of opportunities across stages. A design tool lets someone manipulate an object and immediately see the result. An analytics dashboard allows a user to compare trends without having to formulate every question in advance.

These interfaces don't merely execute instructions. They help users think.

This is an important part of the legacy associated with Steve Jobs and the broader movement toward personal computing: technology should adapt to people, rather than forcing people to adapt to the internal workings of technology.

The GUI was one of the most important expressions of that principle.

So what happens when the next generation of computing asks us to give up the interface and return to a blank box?

The case for going back to the text box

The argument for conversational AI is compelling precisely because modern software has become so complicated.

A business user might spend the day moving between email, a CRM, a collaboration platform, project management software, spreadsheets, and analytics tools. Each application has its own navigation, terminology, workflows, and assumptions about how work should be performed.

Users must learn those conventions, remember where information lives, and figure out which sequence of actions will accomplish their goals.

They become the integration layer between their own applications.

Now imagine replacing much of that navigation with a simple request:

“Review my largest enterprise opportunities, identify the ones most likely to slip this quarter, explain the evidence, and prepare a plan for each account.”

An AI system could retrieve information from the CRM, examine email conversations, review customer support activity, compare historical patterns, and assemble its findings into a coherent response.

The user wouldn't need to know which application contains each piece of information. They wouldn't need to construct a report, select filters, or switch among multiple screens.

The interface would be organized around the user's goal rather than the structure of the software.

This is a genuine advance.

Natural language is flexible. It allows users to express intent without knowing the exact name of a feature or the correct sequence of operations. AI can help them clarify an ambiguous request, explore a problem, and discover capabilities they might never have found in a traditional application.

It also offers something the GUI alone cannot easily provide: a general-purpose way to coordinate work across different systems.

The appeal is not simply that typing a sentence is easier than clicking a series of buttons. It is that the user can stop thinking about the mechanics of the software altogether.

In that sense, AI may be the next step in the long effort to make computers adapt to humans.

But that leaves a critical question unanswered.

When we remove the need to navigate an application, do we also remove the ability to understand what the application is doing?

The problem with hiding the machinery

Imagine a sales leader reviewing a quarterly forecast.

An AI assistant reports that revenue is likely to fall short of plan. It identifies several deals at risk, explains the apparent causes, and recommends actions.

That sounds useful. But the sales leader still needs to understand whether the conclusion is credible.

Are the at-risk deals concentrated in one region? Have close dates been pushed repeatedly? Is one salesperson unusually optimistic? Are the largest opportunities driving most of the forecast uncertainty? Has the underlying data changed since the previous review?

A paragraph of text might answer some of these questions. But an interactive table, a chart, or a purpose-built forecasting workspace can make the relationships visible in a way that encourages further investigation.

The user can scan dozens of opportunities, compare values, spot outliers, inspect individual records, and change the view to test a hypothesis.

The interface supports discovery that the user may not have known to request.

This distinction matters. A conversational system is often strongest when the user can articulate what they want. A visual environment can be particularly powerful when the user is still figuring out what matters.

The same issue appears in other kinds of work.

A financial analyst needs to compare scenarios and inspect formulas. A designer needs to manipulate objects spatially. A software engineer needs to navigate code, inspect dependencies, and understand how changes affect the system. An operations manager needs to monitor changing conditions and recognize anomalies.

In each case, a good interface provides a persistent representation of the work.

The user doesn't have to ask the system to describe every relevant detail. Much of the information is already visible.

Chat can hide that structure behind a sequence of questions and answers. It can force the user to request information they would otherwise see at a glance. And because language models can make mistakes, a confident explanation may conceal an incorrect assumption or an incomplete analysis.

This is the paradox of the AI interface: it can make software easier to operate while making its behavior harder to inspect.

An interface that reduces the effort required to issue instructions may increase the effort required to verify the result.

For simple tasks, that trade-off may be worthwhile. For complex or consequential work, it may not be.

Is chat just the command line in disguise?

There is a tempting interpretation of this shift: we are going backward.

The graphical interface replaced a world in which users needed to learn commands with one in which they could see and manipulate objects. Now we're returning to a text box and asking users to explain what they want in words.

But that comparison misses an important distinction.

A traditional command line requires the user to know the language and syntax of the machine. A conversational AI system can interpret incomplete instructions, infer context, ask clarifying questions, and translate a broad goal into many underlying operations.

A user might ask for a customer briefing without knowing how the relevant records are stored, which APIs to call, or how to combine the results.

The AI handles those details.

That is a significant new abstraction layer. The user describes the outcome; the system determines how to produce it.

In this respect, conversational AI is not a return to the old command line. It is an attempt to move the user even further away from the technical details of computing.

Yet the older interface paradigm still has something important to teach us.

Abstraction is useful when it removes complexity that the user shouldn't have to manage. It becomes dangerous when it hides complexity that the user needs to understand.

A driver doesn't need to understand the engine's internal combustion cycle to operate a car. But the driver does need to see the road, understand the controls, and receive clear warnings when something goes wrong.

Similarly, a business user shouldn't have to understand an application's internal data model to retrieve a report. But they may need to see which records were included, which assumptions were applied, and what will happen when the system takes action.

The objective should not be to expose every technical detail. It should be to expose the right details at the right time.

That is a more demanding design problem than simply putting a chat box on top of an application.

What if the next interface combines both?

The debate between chat and GUI assumes that one must replace the other.

That is probably the wrong way to frame the future.

The most powerful interface may combine the ability to express intent through conversation with the ability to see, inspect, and manipulate the result through a graphical environment.

Imagine returning to the sales forecast.

The user asks the AI to identify risks. The assistant analyzes the data, explains its reasoning, and generates an interactive view of the opportunities it considers vulnerable.

The user can then sort the table, inspect individual deals, compare scenarios, and adjust assumptions. They can ask follow-up questions without losing their place in the analysis.

When they decide what to do, the assistant can draft follow-up emails or recommend changes to the forecast. The user reviews the proposed actions and approves the consequential ones.

Conversation helps the user express intent. The graphical interface helps the user understand and refine the result. Automation handles the repetitive work.

Each interaction model does what it is best suited to do.

This approach could be more transformative than chat alone because AI would not merely replace existing navigation. It could make interfaces more responsive to the work itself.

Instead of forcing every user through the same sequence of menus and screens, the system could assemble the relevant information, controls, and visualizations around the task at hand.

A user investigating a sales problem might receive an interactive pipeline analysis. A developer might receive a code workspace with suggested changes and test results. A finance professional might receive a model with editable assumptions and scenario comparisons.

The interface would become more intelligent without becoming less visible.

This is the possibility worth pursuing: not a world without graphical interfaces, but a world in which users spend less time navigating software and more time working with the information and decisions that matter.

The implications for software companies

This shift has consequences beyond product design.

For decades, SaaS companies have competed partly on the quality of their interfaces. Better navigation, more intuitive workflows, customizable dashboards, and streamlined data entry have been meaningful sources of differentiation.

If AI assistants become the primary place users interact with software, some of that differentiation could become less valuable.

Why would a user open a specialized application to retrieve information or perform a routine operation if an assistant could do it across multiple systems?

Applications whose primary value is presenting accessible data or exposing relatively simple functionality may face pressure. Their users may increasingly access those capabilities through another company's interface.

But it would be a mistake to conclude that the application itself becomes irrelevant.

The underlying product may still own the system of record, enforce business rules, maintain specialized data, manage permissions, and execute complex workflows. Those capabilities can remain valuable even if the user rarely visits the application's home screen.

A CRM, for example, can continue to manage customer relationships and enforce sales processes while an AI assistant becomes the primary interface through which a salesperson retrieves information and initiates tasks.

The more important question is who owns the customer relationship.

If users begin their work in an AI assistant, that assistant may become the primary destination for discovering capabilities, asking questions, and deciding what to do next. The underlying applications could become increasingly interchangeable from the user's perspective, even when their underlying capabilities differ substantially.

That could shift bargaining power toward the companies controlling the AI interface.

For SaaS businesses, the challenge will be to determine which parts of their product must remain visible, which can be accessed through AI, and which capabilities are valuable enough that customers will continue to seek them out directly.

The winners may not be the companies that build the most sophisticated chat interfaces. They may be the ones that combine proprietary value, reliable execution, strong integrations, and the right interaction model for each task.

The interface question is therefore also a business-model question.

Whoever controls the interface may influence distribution, customer loyalty, and the economics of the software beneath it.

The real test: does the user become more capable?

There is a deeper principle underneath this debate.

The purpose of an interface is not merely to make it easier to operate a computer. It is to help a person accomplish something.

Sometimes the best interface is nearly invisible. If a user wants to find a document, summarize an email, or schedule a routine meeting, the system should not force them through unnecessary steps.

At other times, the interface is an essential part of the work. It lets users explore possibilities, recognize patterns, understand relationships, and exercise judgment.

The challenge is knowing the difference.

An AI system that replaces a complicated workflow with a reliable, transparent interaction is progress. One that replaces a clear visual workspace with a stream of text, forcing the user to ask more questions and verify every conclusion, may be a step backward.

The measure of success cannot be how many clicks disappear, how many applications are hidden, or how often users interact with a chatbot.

It must be whether users can accomplish their goals more effectively while retaining the understanding and control those goals require.

That calls for a more thoughtful approach to interface design than simply making everything conversational.

It means designing for the user's intent, but also for their need to explore. Automating routine work, but preserving visibility into consequential actions. Reducing complexity, but not hiding information that matters.

Above all, it means recognizing that different tasks require different ways of interacting with technology.

The last interface?

Perhaps the most important change AI brings is that the application no longer has to be the starting point for every task.

For decades, users have had to learn the structure of software before they could fully benefit from it. AI offers the possibility of reversing that relationship: users express what they want, and software organizes itself around their goals.

That is a compelling next step in computing.

But if the GUI revolution taught us anything, it is that making technology more human does not simply mean making it easier to issue instructions. It also means making the system understandable, responsive, and controllable.

Chat is a powerful new way to express intent. It should not become an excuse to abandon the advances that made computing accessible in the first place.

The future may include fewer applications that users must navigate manually. It may include AI agents coordinating work across dozens of systems. And it may include interfaces that change dynamically as the task evolves.

But the goal should not be to eliminate interfaces. It should be to make them better suited to the people using them.

The winning interface will not be the one that hides the most complexity. It will be the one that removes unnecessary complexity without taking away the user's ability to understand and control the outcome.

If that is the next revolution in computing, it won't be a return to the command line.

It will be the next step beyond the GUI.