MCP-First Product Development: How Do You Know the AI Is Using Your Product Correctly?

Somewhere in the last two years, most of the products we build quietly picked up a second class of user. Not a person with a screen, a mouse and a slow morning — a model, reading a list of tool descriptions, deciding which one to call, and acting on your system on someone's behalf. The Model Context Protocol is what made that user common enough to matter.
MCP is plumbing, and that is exactly why it matters
MCP itself is not clever. It is a standard way for a host application to discover what a system can do and to call it: tools it can invoke, resources it can read, prompts it can reuse. That is roughly it.
The leverage is in the standardisation. Before it, every assistant integration was bespoke — your API, their function-calling format, a glue layer nobody owned. Now one server exposes your product to every host that speaks the protocol. The integration cost dropped far enough that "should we expose this to an AI?" stopped being an architecture decision and became a sprint ticket.
And that is the part worth sitting with. When something becomes cheap, people do it without thinking very hard about it.
The uncomfortable question
Here is the problem I keep running into, and the reason I wanted to write this down.
We ship an MCP server. The model calls our tools. The calls return 200. The user says thanks and closes the window. Everyone involved believes the product was used correctly.
But a successful call is not a correct outcome. A model can pass schema validation on every argument and still pick the wrong tool, filter on the wrong field, update the wrong record, or confidently report a result it never actually retrieved. Our logs show a clean green line. The user's actual intent was missed entirely.
In a UI, this class of failure is loud. Someone clicks the wrong thing, sees the wrong screen, and complains. With MCP, the failure is silent — because the thing that misunderstood you is also the thing writing the summary of what happened.
Why your existing analytics will not catch it
Everything we normally reach for assumes a human and a screen.
- Session replay has nothing to replay. There is no UI.
- Funnels assume a fixed sequence of steps. A model's path through your tools is generated, not designed.
- Error rates look fine, because the errors are semantic, not technical.
- Support tickets never arrive, because the user does not know anything went wrong.
The reasoning that led to the call — the part you actually need — lives in the host application's context window, not in your server's logs. You see the fingerprints, never the hand.
What I would instrument instead
If I were treating an MCP surface as a real product today, these are the signals I would want before adding a single new tool.
- Tool selection distribution. Which tools get called, and which never do. A tool that is never selected is usually not unused — it is badly described.
- Repair rate. How often does a failed call get immediately retried with corrected arguments? A high repair rate is a schema or description problem, and it is the single cheapest signal to collect.
- Argument validity versus semantic validity. Schema-valid input that is nonsense in your domain — a date range of thirty years, a status filter nobody uses — is the clearest sign the model is guessing.
- Abandonment. A call that returns data and is followed by nothing. Either the response was unusable, or it was wrong in a way the model noticed and quietly worked around.
- Destructive-path confirmation. For anything that writes or deletes: how often was it called without an explicit confirmation step, and did a human ever actually see it?
- Task completion, not call count. Define a small set of real tasks and measure whether they end correctly. Call volume is a vanity metric here.
Your tool descriptions are the UI now
This is the shift I underestimated longest. On an MCP server, the interface a model sees is: tool names, descriptions, parameter schemas, and error messages. That is the entire product surface. There is no layout, no affordance, no tooltip, no onboarding.
Which means a few old rules come back with new weight.
- Fewer, clearer tools beat many overlapping ones. Two tools with fuzzy boundaries guarantee a coin flip on every call.
- Error messages are UX copy. "Invalid request" teaches nothing. "
statusmust be one of: open, closed, pending — got 'active'" gets repaired on the next call. - Defaults are decisions. Every optional parameter is a parameter the model will hallucinate a value for eventually.
- Dangerous operations should be structurally hard, not politely discouraged. A description that says "only use this when the user confirms" is a suggestion, not a guardrail.
Where this is still immature
I think it is worth being honest that the ecosystem is young, and these are open problems rather than solved ones.
- There is no Lighthouse for MCP. No standard way to score a server on clarity, safety, or cost. Everyone is evaluating by vibes and a handful of manual prompts.
- Authorisation and scoping are still rough. Least privilege is hard when the caller is a model acting for a user whose permissions you may only partly know.
- Versioning is unsolved. A model cannot read your changelog. Rename a field and every integration silently degrades until someone notices.
- Tool output is model input. Whatever your tool returns goes straight into the context window. If any of it is user-generated, you have handed an untrusted party a channel into the model's instructions. This is prompt injection with extra steps, and most servers do not treat their own responses as a trust boundary.
- Cost and latency have no conventions. Chatty, fine-grained tools feel clean to design and are expensive to use. There is no shared pattern yet for batching or pagination that models reliably follow.
- Observability is fragmented. Every host traces differently. Correlating a user's intent with your server's calls across that boundary is still manual work.
The approach I have settled on
Write the evaluations before the features. Pick ten real tasks a user would actually ask for, run them end to end, and check the outcome rather than the transcript. Keep that set green as the surface grows.
Log every call with its arguments and its outcome, from day one. You cannot reconstruct this later, and the first week of real traffic will teach you more about your tool descriptions than a month of design discussion.
Then re-read your own tool list the way a model would: no context, no product knowledge, no idea what your company calls things internally. Most of the ambiguity is visible from there.
The question that replaced the old one
For years the question behind every interface decision was: can a person find this button and understand what it does?
There is a second one now, and it is harder, because the user cannot tell you when the answer is no. Can a model that will never see your interface still do the right thing on behalf of someone who trusted it — and can you prove it did?
Most of us are still shipping without an answer. That is the gap worth closing.