Today you can hand a GoodBarber app to an AI agent and talk to it like a colleague: "publish this article, adjust that price, schedule a push for 6pm." It does it — for real, on the live app. This isn't a demo assistant sitting beside the tool; it's a way to operate the app in plain language, instead of through screens. And look closely: it's more than a convenience. It's a kind of interface we've never really had before.
The shift: the first interface you don't have to learn
Think about every interface software has ever handed you: a menu, a dashboard, a command line, a back office. They share one thing — you're the one who climbs to meet them. You learn where the buttons are, the logic of the screens, the names of the settings. The tool sets the grammar; you bend to it.
We put a lot of care into our own back office, and I stand by it — a good dashboard is earned, not free. But even the best one is still something you have to learn. An agent flips the direction, and for the first time it really flips: you don't learn its interface, you state an intent and it translates that into operations on the app. This isn't one more screen, prettier or faster. It's a different kind of interface — the first that adapts to you instead of the other way around.
That has a consequence people underrate. The person who never quite mastered the back office — no time, no appetite for it — can now run their app anyway, just by describing what they want. For a platform whose whole job is putting technology within everyone's reach, that's not a small move. And it changes what your app has to expose about itself.
What that asks of the app
An agent doesn't click; it calls. So to be operable this way, software doesn't need prettier screens — it needs to expose what it can do, as callable actions: publish, update, schedule, notify, measure. And any agent has to understand them without someone writing a bespoke integration for each one — hence a standard, MCP, that agents already speak natively. Because the standard is stable, the same set of actions works with this year's agent and next year's: the app isn't married to any one assistant.
None of that is spectacular, and in 2026 it's expected — plenty of platforms are wiring it up. The interesting work isn't exposing actions; it's exposing them well. Agents chain steps: ask one to "publish this article in the News section and let readers know with a push," and it has to run several operations in the right order — find the right section, create the article there, confirm it's actually live, and only then fire the notification. For it to get that right, every action has to be named clearly, scoped, and described so the agent knows which one to reach for and when. Leave an action ambiguous, or two of them too alike, or a parameter underexplained, and it'll notify readers before the article is live — or publish it in the wrong place.
That's where the real work sits, and it's less glamorous than it sounds: writing, for a machine, the manual of what the app can do. The shift is quiet but deep. The unit of interface is no longer a pixel to draw — it's a verb to define. You're no longer designing only screens for a human to navigate; you're designing capabilities for an agent to compose.
The agent acts — you keep the wheel
One caveat, because an interface that acts isn't an interface that displays: the agent runs real operations on a live app. So it works inside a frame you set — access limited to your app and yours only, actions it confirms and that you can review. It acts; you keep the wheel. Simple to say, and it has to stay simple to check.
Where this could go
Today, this interface reaches the management of the app you build with GoodBarber — its content, its catalog, its campaigns. It stops at the back-office door.
The next step, a bigger one, is to cross that threshold: for the app itself — the one your users open — to expose its own functions the same way, and become something an agent can use in turn. That's not speculation anymore: as I was finishing this article, Lovable announced exactly that — generated apps shipping their own MCP server. The direction is confirmed, and it follows from everything above — including the part that doesn't get easier: the same care that goes into naming, scoping and describing the actions of a back office will now have to go into the app itself. The day an app is designed as much to be spoken to as to be looked at, "building an app" won't mean quite the same thing.
In the meantime, the shift has already started — in one specific, entirely real place: the first interface to your app that no one has to learn.
Top comments (1)
The unit of interface is no longer a pixel to draw — it's a verb to define.' That is an incredible quote and perfectly sums up this paradigm shift! As apps cross that threshold and ship their own MCP servers, how do you see developers managing the security/permission layer when agents start chaining actions autonomously? Brilliant write-up!!