AI is an interface

For most of computing history, the interface was the tax you paid to use a system. You learned its menus, its fields, its query language, its API. The software held a model of the world, and using it meant translating what you wanted into that model by hand. The people fluent in that translation were a profession.

AI’s most durable job is to take that tax off, and the job is narrower than the hype around it: it is the interface. You say what you want in your own words, and the system does the translation that used to be yours to do. It maps your intent onto the task you meant, and onto the operations across whatever tools carry it out. Plain language in; the right actions in the right systems out.

It is worth being precise, because “AI” gets stretched to cover everything. This is the narrow claim, and it is the one that holds: AI as the layer that takes “which segment is churning, and why” and turns it into the joins, the queries, the significance tests, and the calls to the four systems that actually hold the answer. The intelligence can sit wherever it sits. The interface is the part that just got rewritten, and the rewrite is where most of the value is.

You can see why by looking at what the old interface gated. Analytics lived behind SQL and a BI tool, so the people who could ask the warehouse a question were the people who had learned its dialect; the analyst was, in effect, a human interface between a manager’s question and the database. Every system worth using carried a toll like that: a language, a console, a certification. When the interface becomes plain language, the toll comes off, and the person with the question and the person who can phrase it in the tool’s grammar become the same person.

For anyone building, that moves the hard part. If AI is the interface, the product is the mapping: intent to task to systems, done reliably, against real data and real tools that are messy in all the ordinary ways. The model is the commoditising half. The half that earns its keep is the binding between a sentence and the operations it should set off, done so the result can be trusted. That becomes its own discipline the moment a wrong mapping is an action taken rather than a paragraph produced.

It hits product design hardest, because design was the interface. The job used to be drawing the screens: every state, every control, every path a user might take, rendered as something to click. When language carries the range instead, that surface shrinks; you don’t draw a screen for each of the thousand things someone might ask, because the model takes the input you never enumerated. The pixel-level core of the role is exactly the part that flattens, into the same conversation the PM and the engineer are now having, because the four modes were always one feedback loop and the interface was the seam holding them apart.

What’s left for design is the part that was always the harder half. Deciding where language is the right interface and where a direct control still wins. Shaping the tools the model composes so the pieces stay legible. Designing how the system shows its confidence, shows its working, and recovers when it’s wrong, which is where trust is won or lost. And the judgment under all of it: what good output looks like, what the defaults should be, which few surfaces still deserve to be crafted by hand. That is not less design. It is design measured in whether the thing can be trusted and understood rather than in how many screens got drawn. The new role looks more like designing a system’s behaviour than decorating its surface.

The shift was never that the machine got clever. It is that you stopped having to think like the machine in order to use it. That was always the tax. Taking it off is most of what AI is for.