For three months I've been running what's technically called a Model Context Protocol server in front of a live SaaS. The protocol itself is the boring bit. The thing worth writing down is what changed once I stopped tacking AI on at the end and started treating it as the first consumer of everything I build.
I stopped writing endpoints for humans. I write tools for models, and humans get the interface for free.
The protocol bits are documented well enough elsewhere, so I'll skip them. This is about what the shift feels like when you're the one operating it, and why I'd never go back.
The old shape
The way I used to build went like this. Design the data model. Build the API to expose it. Build the dashboard on top. Then, eventually, maybe, write a thin "AI feature" that wraps a couple of endpoints. The AI was always the last layer, the bit you bolt on for the marketing screenshot.
The trouble with that shape is the AI layer is always second-class. It has to politely ask the API for permission to do things the API was never designed to let it do. You see the mismatch everywhere. Bad error messages the model can't recover from. Endpoints that return too much or too little. Auth that doesn't map to what an agent actually wants to do.
The new shape
Now the model is the primary consumer. The tool list, meaning the actual surface of what an agent can do, is the product. Everything else sits downstream of that.
I curate the tools the way I'd curate a feature set. I don't expose every endpoint, just the twenty or so things an operator needs to get useful work done. Each one has a description the model reads, error messages that name the next correct move, and an auth scope that ties back to the same permissions a human has.
Once that exists, the dashboard is another client of the same surface. It happens to be a React app instead of a model, but it talks to exactly the same tools. There is no second-class AI feature anymore, because the AI surface is the product surface.
The tool list is the product. The endpoints are an implementation detail.
What changed in practice
A few things stopped being problems.
Customer requests that used to take a sprint now take a sentence. "Can we export this report to my agent?" Yes, because every report is already an MCP tool. I don't ship it as a feature. I tell them what's already there.
Onboarding got easier. Operators don't read docs. They paste their workflow into Claude and the model works out which tools to chain. It's a better onboarding engineer than I am.
I stopped writing new dashboard features against the database. New features get added as MCP tools first, and the dashboard consumes them. This sounds backwards. Once the habit is there, every new feature ships with the UI and the AI surface in the same change, and you stop noticing you're doing it.
What I'd tell someone starting
Don't think of AI as a feature you'll add later. Treat the AI surface as the primary product. Build the tools first, then build the dashboard against them. If you can't describe what your product does as a list of tools an agent could call, you don't have a clear product yet.
The protocol doesn't matter much. It's MCP today and it'll be something else in two years. The decision is what compounds: the model is your first user, and it gets to use your product the same way the operator does.
I've been writing code for a long time, but I only went all-in as a founder this past year. Of everything that changed my output, it wasn't a new framework or a new database. It was that one decision. Everything I've shipped this year has been built that way, and I'm not going back.