Much of the industry I have worked in is centred on graphical interfaces, where enormous effort goes into making machines easier for humans to use. Yet the screen is only one kind of interface. An interface is not defined by its appearance but by its purpose: it is the boundary across which information, intent, and control are exchanged. Some interfaces are visual, others textual, mechanical, electrical, or entirely invisible to human beings.
For much of computing history, the interfaces that received the most attention were those designed for people. Websites, applications, dashboards, and operating systems all focused on making machines understandable and usable. Increasingly, however, interfaces are being designed for machines themselves. APIs, protocols, event streams, and autonomous agents now spend more time communicating with one another than waiting for human input. As that balance shifts, I find myself wondering whether our understanding of interfaces needs to shift with it. What is an interface really? What has it always been for? And what is it becoming?
Where interfaces came from.
The interfaces we picture first are the human-facing kind, and they exist because machines were capable long before they were usable. The early ones could compute plenty; the trouble was that reaching that capability meant punch cards and priesthood. So we built friendlier seams to close the gap. Terminals replaced cards. The desktop metaphor replaced the command line for most people. Touch replaced the cursor for a generation that never met one. Each step was the same move repeated: take capability that already existed and put it within reach of more people. The interface was never the point. Access was.
What the interface was always for.
Strip it down and an interface does one thing: it translates. It takes raw capability and makes it legible to whatever is on the other side. For the human-facing kind, that meant making capability learnable and safe for a person to drive: encoding what you are allowed to do, what you are not, and what just happened when you did. That translation layer was often the whole product. Two companies could have the same underlying capability, and the one that made it usable won, not because its engine was better, but because a person could actually get at it. Usability was a moat, and for decades it was a deep one.
When the human stops being in the loop.
Here is what unsettles me. A growing share of work no longer has a human at the surface at all. Agents call APIs. Systems integrate directly. One model hands structured output to another and neither of them needs a screen, a button, or a tooltip. The seam is still there (the API is every bit an interface), but it is no longer one a person looks at. For that traffic, the human-facing surface is not value. It is overhead: a translation into a language nobody in the conversation speaks. If the thing consuming your capability is a model, it is fair to ask what, exactly, the screen is for.
The examples are everywhere once you look for them. Stripe won by being an API first and a dashboard second; the money moves through code that no human watches in the moment it clears. A Kubernetes cluster reconciles a state you declared in a file: the control loop does the work and clicks nothing. A GitHub Actions pipeline builds, tests, and ships on a push, with nobody sitting at a console approving each step. And an agent stringing together a dozen tool calls is, at every hop, one program handing structured data to another. In all of it, the polished screen we would once have laboured over is either absent or sitting unwatched off to the side.
I do not think that question has a comfortable answer, and I distrust anyone who says it does. A real portion of what we used to lovingly design and polish is becoming a back end with no front. Pretending otherwise is the kind of attachment that gets you overtaken.
From input to insight.
I do not think the answer is a single prompt box swallowing everything, though that is the fashionable guess. What I see instead is a change in what the human-facing surface is for. As agents take over the doing, the controls thin out: fewer buttons to press, fewer fields to fill, fewer of the small manual actions we used to design whole screens around. But the surface does not leave with them; it changes job. It stops being the place where you put work in and becomes the place where you watch it happen. It is the difference between a form where you set the replica count by hand and a dashboard where you watch a rollout move: pods going green, error rates holding flat, traffic shifting across, and you stepping in only if something looks wrong. Less a control panel you operate, more a window you read.
The objections, and what survives them.
Before I commit to letting it go, the objections deserve a fair hearing, because there are good ones. You cannot sell what nobody can see: software is still bought from a demo, and a back end with no front is a hard thing to put in front of a buyer. People learn a system through its surface; strip the screens away and onboarding becomes an act of faith. Regulated work needs somewhere to stand: an auditor, a compliance officer, a court all want a place to look and a record of who did what and why. And, as we have already said, even machines need an interface to each other: an API contract, a tool definition, an OpenAPI spec is still something a person designed, still a surface that can be clear or confusing. The interface does not vanish when the human leaves the loop. It changes audience.
Most of these hold, and I think they sharpen the point rather than blunt it. The sales demo, the onboarding tour, the audit log: none of them is an interface for doing the work. They are interfaces for buying it, learning it, answering for it. That is exactly the migration I am describing: away from the surface where a human drives the capability, toward the surface where a human understands and vouches for it. The agent-to-agent contract is the same lesson in another key. Design simply moves to where the consumer is. If the consumer is a model, you shape the schema with the care you once gave the screen: clear names, sane defaults, errors that explain themselves. The work does not stop being interface work. It stops being screen work.
What is left, and why it matters more.
So I land somewhere less tidy than I started. The interface as a thick translation layer wrapped around every capability is fading, and I think the honest move is to let it go. But there is a second interface underneath it, and that one is growing. Even when the machine does the work, a human still has to understand it, trust it, correct it, and answer for it. Automate everything beneath the surface and you raise the value of the surface that remains, because it is now the only way left to see into a system doing more than ever on its own. The screen stops being a control panel for the capability and becomes a control panel for the autonomy: the seam where a person can still see what happened, trust it or refuse to, and reach in when it is wrong. That job is not shrinking; it is growing, precisely because the cost of not noticing has gone up. It was never about the pixels. It was about keeping a person in a position to understand and decide. The more capable the machine becomes, the less that position is optional.