Software Will Die, But GUI Won’t

For the past several decades, we have treated “software” and “interface” as almost the same thing. We open an app, see a window, a set of buttons, a table, or a dashboard, and we call that software. But in the AI era, this connection will be broken.

We believe that much of what we call “software” today will gradually disappear. But GUI will not disappear. In fact, GUI will become even more important, just in a very different form. The reason is simple: software has never been the end goal. Software has always been a medium for helping humans complete tasks.

Why software existed in the first place

If we go back to the early days of computing, software was created to help humans operate the computing and storage power of hardware. People wanted to write documents, calculate numbers, manage customers, schedule meetings, process emails, and analyze data. Computers had the power to support these tasks, but they did not understand human intent directly. So we built software to package computational capability into something humans could use.

But there was a historical constraint: developers were few, users were many. A small number of people built software, and a large number of people used it. To serve as many people as possible, software had to become standardized. This gave us fixed menus, fixed workflows, fixed data structures, and fixed ways of interacting with computers. It also created the central relationship of the software era: humans had to adapt to software.

You had to learn Excel formulas, Salesforce workflows, Jira task management, Notion’s information architecture, and the operating logic behind every tool you used. Software did not truly understand you. It simply offered a standardized set of capabilities and asked you to enter its world.

“Best Practice” is a byproduct of standardized software

To make software usable by many people, developers abstracted common methods from repeated tasks and turned them into standardized workflows. Over time, we started calling these workflows “Best Practices.”

This made sense in the pre-AI era. Software could not dynamically generate a personalized workflow for every individual. It had to define a recommended way of doing things first, and then users had to learn and adapt to that way.

So Excel is not just a spreadsheet tool; it also implies a way of handling data. Salesforce is not just a CRM; it also implies a way of managing sales. Project management software is not just a task list; it also implies a model of team collaboration. In many cases, what companies buy is not only software functionality, but also the packaged Best Practice behind the software.

But this is also the problem. Best Practice is designed for the majority. It does not necessarily fit every person, and it certainly does not fit every specific situation. In the past, we had no better option, so we accepted standardization. AI changes that assumption.

AI makes software as a medium less necessary

AI, especially proactive and autonomous agents, gives us a chance to return to the essence of the problem: users do not really want to use software. Users want to get things done.

If an agent can understand a goal, read the context, plan the steps, call the right tools, generate the result, and ask the user to confirm key decisions when necessary, then many of the intermediate steps in traditional software can be compressed. Users no longer need to enter a specific tool, learn its workflow, and translate their task into the format that the software understands. They can simply express the outcome they want: summarize my most important emails today, schedule next week’s customer meetings, write a report based on these materials, follow up on this project and remind me when needed, or turn this messy information into an actionable plan.

In this process, software is no longer a fixed environment that users must adapt to. Computation and interaction begin to adapt to the user. This is what we mean when we say software will die. Computing will not disappear. Products will not disappear. Interfaces will not disappear. What will fade away is the fixed software form that requires humans to learn, adapt, and conform to predefined workflows. It will be replaced by more dynamic, proactive, and personalized AI systems.

But this does not mean GUI will disappear

There is a common misconception: many people equate software with GUI, and AI with chat. From there, they reach an overly simple conclusion: if AI is the future, then everything will become a chat box, and GUI will no longer matter. We believe this is wrong.

Chat is not the only interface for AI. GUI is not exclusive to traditional software. Even in human-to-human collaboration, we do not rely only on conversation. We use whiteboards, spreadsheets, charts, documents, kanban boards, diagrams, and dashboards. Human beings process information in multiple ways.

Text is powerful for expressing intent, explaining reasoning, and asking questions. Graphics are powerful for presenting structure, status, relationships, and progress. You can describe a project’s status in one sentence, but a board helps you instantly see what is blocked. You can explain financial performance in a paragraph, but a chart helps you immediately understand the trend. You can say in a chat that several emails need attention, but a dashboard helps you quickly judge priority, status, and next actions.

So the real question is not whether GUI will be replaced by chat. The real question is: what kind of GUI do we need in the AI era?

The future is not chat-only. It is Generative UI + CUI

We believe products in the agent era should not be limited to smarter chatbots. They should become collaborative systems made of both CUI and GUI. CUI, or Conversational User Interface, is good for expressing intent, clarifying needs, and discussing ideas. GUI, or Graphical User Interface, is good for displaying results, organizing information, and enabling fast action.

More importantly, GUI in the AI era should not be a fixed interface designed in advance. It should become Generative UI. The interface should be dynamically generated based on the task, the context, the user’s preferences, and the current state.

When the user needs to process emails, the system can generate an inbox dashboard. When the user needs to schedule meetings, it can generate a calendar view. When the user needs to follow up on tasks, it can generate a task board. When the user needs to analyze information, it can generate structured reports, charts, and actionable cards. When the user needs to collaborate, it can embed interactive components directly inside the conversation instead of returning only text.

This is the new role of GUI in the AI era. It is no longer a fixed control panel inside traditional software. It becomes an interaction surface generated by AI to help users complete tasks.

SureThing’s declaration: building problem-solving capability from the ground up

This is exactly what SureThing is building.

We are not trying to create another piece of software that asks users to enter a new system, learn a new interface, adapt to a new workflow, and then complete tasks inside that system. That is still the old logic of the software era: define the tool first, then train the user.

SureThing believes the AI era should work the other way around. The starting point of a product should not be “what software features do we provide?” It should be “what problem does the user actually want to solve?” When a user faces an email that needs action, a pile of messy information, a project that needs to move forward, a meeting that needs to be scheduled, or even a goal that has not yet been clearly expressed, the system should proactively understand the context, identify the nature of the task, organize the required information, generate the right interaction surface, and invite the user to participate at the moments where human judgment is needed.

In other words, SureThing is building problem-solving capability from the ground up, not another piece of software that users must learn and adapt to.

This means we will not simply insert AI into traditional SaaS, and we will not compress every interaction into a chat box. SureThing is designed to make AI, CUI, and GUI work together. Conversation helps understand intent. Graphical interfaces help present structure. Agents help move tasks forward. Dynamically generated UI helps users review, modify, confirm, and complete work.

In this new paradigm, users do not need to ask, “Which software should I open?” They only need to face their goals. The system should decide whether the task needs a dashboard or a task board, a summary or an editable document, a calendar view or a suggested reply, immediate user confirmation or preparation work that the agent can complete first.

This is SureThing’s core belief: future products should not force users to adapt to software. They should make computational capability adapt to humans. They should not place people inside standardized workflows. They should generate the right path around each person’s context. They should not merely provide tools. They should help people actually get things done.

Software will die, but GUI will evolve

So when we say Software Will Die, But GUI Won’t, what we really mean is this: traditional software, as a fixed intermediate medium, will become less central. But graphical interfaces, as an efficient way for humans to understand, judge, and act on information, will continue to exist.

They will evolve from static interfaces into dynamic interfaces, from generic interfaces into personalized interfaces, from software-defined interfaces into AI-generated interfaces, and from “humans operating software” into “humans and AI solving problems together.”

This is also SureThing’s declaration: AI should not be trapped inside chat boxes, and GUI should not be trapped inside old software. The most powerful products of the future will combine proactive agents, conversational interaction, and generative graphical interfaces to create the best way for each person to solve problems.

Software will die, but GUI won’t.

GUI will become the true interface for humans and intelligent systems to solve problems together.