For three months I've been running what's technically called a Model Context Protocol server in front of a live SaaS. The name of the protocol isn't the interesting part. What's interesting is what changed when I stopped treating AI as a feature I tack on at the end and started treating it as the first consumer of every product I build.
I stopped writing endpoints for humans. I write tools for models, and humans get the interface for free.
This isn't a tutorial. The protocol bits are well-documented elsewhere. What I want to say is what the shift actually feels like as an operator, and why I'd never go back.
The old shape
The way I used to build was: design the data model, build the API to expose it, build the dashboard on top, and then, eventually, maybe, write a thin "AI feature" that wraps a couple of endpoints. The AI was always the last layer, the bolted-on bit, the marketing screenshot.
The problem with this shape is that 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. The mismatch shows up everywhere: bad error messages the model can't recover from, endpoints that return too much or too little, auth that doesn't model what an agent actually wants to do.
The new shape
The new shape is that the model is the primary consumer. The tool list, the actual surface of what an agent can do, is the product. Everything else is downstream of that.
I curate the tools the way I'd curate a feature set: not every endpoint, just the twenty or so things an operator needs to do useful work. 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 uses.
Once that exists, the dashboard becomes 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's no second-class AI feature. 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?" The answer is yes, because every report is already an MCP tool. I don't ship it as a feature. I just describe what's already there.
Onboarding got easier. Operators don't read docs. They paste their workflow into Claude and the model figures out which tools to chain. The model is 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 you have the discipline, every new feature ships with both the UI and the AI surface in the same change without you thinking about it.
What I'd tell someone starting
Don't think of AI as a feature you'll add. Think of 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 yet have a clear product.
The technical protocol you use is not the thing. MCP today, something else in two years. The shape of the decision is what compounds: treat the model as your first user, not your last feature.
I've been writing code for a long time, but I only went all-in as a founder this past year. The thing that has changed my output the most isn't a new framework or a new database. It's deciding the model gets to use my product the same way the operator does. Everything I've shipped this year has been built that way. I'm not going back.