GUIs Are Shrinking: AI Took the Judgment Calls That Built Them
The Era of the GUI Is Over
Hello everyone, I'm Old Liu
It's been quite a while since I last wrote. I've been busy updating my development environment, the trigger being that my last Claude account got banned.
After reorganizing the agents, skills, and subscriptions I use daily, it suddenly struck me that GUI-style interaction may be gradually weakening.
AI is replacing not just the software development process, but possibly software itself.
Let me start with a small everyday change.
My Archiving Method Changed
I'm in the habit of keeping complete archives of good articles I come across online.
Partly for easier searching and organizing later. Partly because some articles look fine today but may be gone tomorrow if the wind shifts. For content that inspires me, I'd rather keep a copy in hand.
In the past, I wrote a small app myself. After pasting an article link, it automatically downloaded the content, saved it to a specified directory, and added relevant keywords to the filename. Then I manually added the file link to the corresponding note.
The core part of the flow was done by software; I only handled the parts software couldn't automate.
Now I've changed my approach. When I see an article worth saving, I hand the link to AI directly. AI follows my predefined archiving skill: it downloads, adds keywords, saves the note link, and can even create cross-links between multiple notes based on the article's content.
Why Complex GUIs Were Needed in the Past
For software to finish a job, two kinds of steps usually come up.
One kind has fixed rules. Which directory an article downloads to, what format the file is saved in, which keywords go into the name: all of this can be written into code in advance. As long as the input is clear, the script runs reliably.
The other kind requires on-the-spot human judgment. Whether an article belongs under social sciences, natural sciences, or economics, and which notes it should link to, is hard to handle with a single fixed rule.
In the past, those judgments had to go to a person. The software's job was to put the information that needed judgment on screen, so a person could see it clearly, operate it conveniently, and make as few mistakes as possible.
That's how we got step-by-step guided workflows, draggable cards, quick tabs, and all kinds of carefully designed interactions.
The GUI carried an important responsibility here. It wrapped the decision steps the program couldn't complete on its own, guiding a person through the whole workflow step by step.
Without those interfaces, people would have to memorize commands, parameters, and process sequences themselves. The GUI put choices and feedback right in front of you, which is how the value of using software became visible.
AI Has Taken Over Part of That Judgment
Now, that premise has changed a bit.
Simple judgment on content, sorting, organizing, categorizing, even building cross-references, AI already does very well. For tasks like article archiving, you don't even need a high-spec model; a Flash-tier model can handle the entire job.
Choices that once had to be made by people can now be handed to AI.
I should clarify one point: I don't hand everything to AI. That would actually be slow and burn tokens.
In my archiving flow, most execution work still runs via script, and downloading and archiving articles is a typical example.
Scripts keep handling fixed-rule execution; AI takes over the steps that require judgment based on content. Each does its own job; there's no reason to abandon a stable script just to use AI.
It's just that in the past, we designed pages, buttons, and guided flows specifically to let users complete categorization, selection, and confirmation. Now AI can handle part of that work based on article content and preset rules, and those interactions naturally lose their reason to exist.
The GUI Won't Vanish Entirely
From here, it's easy to jump to a more radical conclusion: software will only need one input box in the future, and everything else can go.
I don't see it that way.
Take opencode, which I'm currently using: its GUI has kept expanding and improving in recent iterations. Status display, result viewing, process confirmation: these interactions still have real value.
So, AI taking over some decisions doesn't mean AI can replace all GUIs.
When I judge whether an interface is still necessary, I first look at the step it serves.
If it only guides a person through a categorization that AI can already handle based on context, that interface deserves re-examination. If it helps a person view status, compare results, confirm critical operations, or make fine adjustments, keeping the GUI remains straightforward.
The contraction of the GUI is concentrated in the part AI can complete on its own. The visible, clickable interfaces that remain will persist for a long time.
You Can Re-Dissect Your Own Workflows Too
If you also want to work AI into your daily routines, I'd suggest not rushing to swap tools. Pick a recurring chore and break its steps apart.
First, find the fixed-execution parts
Downloading, saving, renaming, moving files: as long as the rules are clear, hand them to scripts first. Stable, low-effort, and easy to troubleshoot when something goes wrong.
Then find the judgment parts
Categorizing, extracting keywords, building content associations: steps that used to require a human to glance and decide. Now you can try handing them to AI, while stating the judgment criteria and output format clearly.
Keep key confirmations in your own hands
For choices where your personal preference isn't clear, where mistakes are costly, or where you bear responsibility for the outcome, don't rush to automate everything. Keeping manual confirmation is usually safer.
Finally, check what purpose the interface has left
Once execution and judgment in a workflow both have new homes, whether the original buttons, pages, and guided flows are still necessary becomes much easier to see.
Also, don't rush intensity. First, get one trivial chore's full flow working end to end. After it works, you'll naturally know which parts suit scripts, which suit AI, and which still need a convenient interface.
What You Genuinely Save Is Attention
I find this way of working very comfortable now.
Shorter flow is useful, of course. But what actually feels best in real use is that I no longer have to switch my entire mental workspace to "how to archive this" after seeing a good article, then drag my attention back to the article's content once archiving is done.
Many trivial tasks don't take much time individually; the problem is that you have to set aside whatever you're currently doing. Such switches repeat constantly, and the switching itself drains a lot of energy and attention.
Scripts save operation time; AI saves attention.
So the real value of a reduced GUI isn't merely fewer buttons on screen, but fewer task switches in your head.
You can start today by picking one recurring chore, separating fixed execution from human decision, and trying to run one automated flow end to end.
Which recurring chore have you recently handed to AI? Did it save you operation time, or reduce your attention switching? Feel free to discuss in the comments.
Old Liu has done client-side development for a long time and keeps practicing AI programming and workflow restructuring. This is where I record real projects, everyday experience, judgments, and pitfalls, trying to lay out applicable scenarios, costs, and boundaries clearly.
My past articles are also organized in a GitHub repo, for your convenience.