Every era of software has a dominant interface. The command line gave way to the desktop window. The window gave way to the web page. The web page gave way to the app on your phone. Each shift was really an argument about who does the work: the machine got a little more capable, and the human got to point and click at a slightly higher level of abstraction instead of typing the exact instruction.
The next shift breaks that pattern. For the first time, the machine can read the instruction, understand the goal behind it, and carry it out. When that is true, the whole premise of the graphical interface starts to wobble. The screen full of buttons was a compromise. It existed because software could not understand what you wanted, so we drew you a map of everything it could do and let you navigate. If something can understand what you want, the map is overhead.
2027 will be the year that stops being a research demo and starts being the default. It will be the year of the personal assistant. Not a chatbot you visit, an assistant that acts.
The static UI was a workaround, not a destination
Think about what a SaaS dashboard actually is. It is a visual encoding of an API. Somewhere underneath, there is a set of operations the product can perform: create the invoice, move the deal to the next stage, schedule the send, export the report. The dashboard is a human-readable rendering of those operations, laid out in panels and menus and modals so a person can find the one they need and trigger it by hand.
We spent twenty years getting very good at drawing those renderings. Design systems, onboarding flows, empty states, tooltips. An entire profession exists to make the map easier to read. And it worked, because the alternative was worse. The alternative was the API, and the API was for engineers.
But notice what the person is doing at that dashboard. They are translating. They have a goal in their head, "chase the three clients who have not paid," and they are decomposing it into a sequence of clicks: open billing, filter by unpaid, sort by date, select the three, open the reminder template, edit each one, send. The software cannot do the decomposition, so the human does it. Every time. Forever. That labor is invisible only because we are all so used to it.
The static UI was never the destination. It was a workaround for machines that could not understand goals. The moment they can, the workaround becomes the bottleneck. You do not want to click through seven screens to chase three invoices. You want to say "chase the unpaid invoices" and have it done, and be shown the result so you can approve it.
Assistants will not use your app the way you do
Here is the part people get wrong. They imagine the assistant as a faster human, sitting at the same dashboard, moving the same mouse, clicking the same buttons, just quicker. Some of the early demos literally do this: a model that drives a browser, hunting for the checkout button like a person would.
That is a dead end for anything that matters. Driving a graphical interface built for human eyes is slow, brittle, and expensive. The button moves and the whole thing breaks. It is the machine pretending to be a person pretending to operate a machine. Three layers of translation where there should be zero.
The assistant does not want your pixels. It wants your operations. It wants the thing the dashboard was drawn on top of: the actual set of commands the software can run. Give it those directly and the whole awkward dance disappears. No hunting for buttons, no screen-scraping, no guessing which modal holds the setting. Just: here are the operations, here is the goal, go.
Which is why the interface of the assistant era is not going to be graphical at all. It is going to be the command line, reborn.
The command line was right all along
There is a reason engineers never left the terminal, even through every graphical revolution. The command line is the most direct expression of intent we have. A command is a verb and its arguments. It composes. You can pipe the output of one into the input of the next, script it, schedule it, and repeat it exactly. It has no empty states or onboarding flows because it does not need them. It assumes you know what you want and lets you say it.
For humans, that assumption was often too strong. Most people do not know the exact command, and a blank prompt is intimidating. So we built the graphical layer to hold their hand. But an assistant does not need its hand held. An assistant is comfortable with a verb and its arguments. The command line was too direct for people and exactly right for machines. We just did not have the machines yet.
So the arc bends back. The interface humans reach for becomes conversational: you say what you want, in your words. And the interface the assistant reaches for underneath becomes the command line: precise verbs, real arguments, composable, scriptable, auditable. You talk to the assistant. The assistant talks to the tools in their native tongue. The dashboard, the thing in the middle that made both sides translate, quietly goes away.
This is a better world for everyone, including the products. A tool that exposes clean commands is a tool an assistant can actually use well, which means it is a tool that gets used more, not less. The products that thrive in 2027 will be the ones that stop thinking of themselves as a set of screens and start thinking of themselves as a set of capabilities an agent can call.
Trust is still the whole game
None of this works if you cannot trust it. An assistant that acts on your behalf is holding real power: it can send the message, move the money, change the record. Power without a way to see and approve what it did is not something anyone sane will hand their work to.
So the command line comes back with a property the graphical era quietly lost: legibility. Every action an assistant takes is a command, and a command is a thing you can read, log, and reason about. You can see exactly what it ran, in what order, with what arguments. You can require approval before the ones that matter. You can replay the whole session and understand it. Compare that to a model clicking around a browser, where the only record is a blurry screen recording and a shrug.
The assistant we would actually trust is not the one that does the most on its own. It is the one that is the most transparent about what it is doing and the most disciplined about asking first. It should do the boring decomposition for you, the seven clicks, the copy and paste, the context you keep re-typing. It should not do the deciding for you. That line, act on the small things, ask on the big ones, show your work always, is the difference between a tool people adopt and a demo people fear.
Why we built the Kosuke CLI
We build software for a living, so we felt this shift in our own work first. The best version of building with AI is not a person clicking through an IDE while an agent watches. It is an agent doing the work directly, through commands, while the person stays in the loop to decide and approve. The interface that made that natural was not a new dashboard. It was the terminal.
So we released the Kosuke CLI. It is our bet on everything above, made concrete. Your agent does not pantomime a human clicking through a UI. It runs real commands against your codebase, in your environment, the same way an engineer would, except it does the tedious part and hands you the result to review. You describe the goal. It decomposes it into commands. You see every one, and you approve what ships.
We think this is the shape of the whole next era, not just for code. The dashboard was a compromise we made because software could not understand us. Now it can. The assistant will take our goals, speak to our tools in their own language, and hand us back the result to approve. 2027 will be about personal assistants, and the assistants will live at the command line. We are starting where we know best, and building out from there.
You can try the Kosuke CLI today.