What is MCP, and what changed once I started using it?

I kept hearing about MCP everywhere. In Claude Code, in Sanity, in tutorials about new tools that wanted to talk to AI. Every time I read about it, the explanation went technical fast: Model Context Protocol, JSON-RPC, stdio servers, tool definitions. I would close the tab.

The short answer turned out to be small. MCP is a shared language that lets AI assistants like Claude actually do things in the apps I use, instead of just talking about them. That is it. The plumbing is interesting if you build the tools; if you just use them, the thing you need to know is that MCP is the moment Claude stopped being a chat window and started being a coworker who can reach into my tools.

This post is what I wish someone had told me before I went down the documentation rabbit hole. What MCP is. What it changes about how I work. Why I think it matters even if you have never written a line of code.

What is MCP, really?

MCP stands for Model Context Protocol. The word protocol sounds intimidating, but it just means a shared way of talking. Email has a protocol. Texting has a protocol. The thing that lets your phone connect to your wifi has a protocol. They are all just agreements about how two systems exchange messages so they can understand each other.

MCP is the same idea, for AI. It is the agreement that says: here is how an AI assistant like Claude finds out what an app can do, and here is how it asks the app to do those things.

Think of it as a USB-C port for AI assistants. Before USB-C, your laptop needed a different cable for every device: one for the printer, one for the phone, one for the screen, one for power. After USB-C, the same socket works for everything that speaks the standard. MCP does the same thing for AI: one shared protocol, lots of apps that can plug in.

What does that look like in practice?

Here is the difference, in plain terms.

Before MCP: I would tell Claude, write a blog post about X. Claude would write the blog post. Then I would copy it, open Sanity, paste the title into one box, the body into another, fix the formatting, upload an image, add tags, and click save. Claude was a writer. I was the typist.

After MCP: I tell Claude the same thing. Now Claude writes the post and also pushes it straight into Sanity as a draft, with the right title, body, tags, and image. I read it and click Publish. Claude is the writer and the typist. I am the editor.

That second version is only possible because Sanity ships an MCP server. The server is a small program that tells Claude what Sanity can do: create documents, search content, upload images, and how to ask for those things. Claude reads that list, picks the right tool for the job, and calls it.

It is not just Sanity. There are MCP servers for Gmail, Google Calendar, Google Drive, Figma, GitHub, my IDE, even my brokerage account. Every one of them turns Claude from a chatbot that knows things into a coworker who can reach into the app and do the thing.

Do I need to be a developer to care about MCP?

This is the part I think gets buried under the technical writing. The answer is no.

If you ever use an AI assistant for work and find yourself copying its output into another app, MCP is the thing that makes the copying step disappear. It is not a new model. It is not a clever prompt. It is just the wiring that lets the AI you already use reach the apps you already use.

The tradeoff is that every app has to ship its own MCP server to participate. Right now, Sanity does, Figma does, Google does, GitHub does, Anthropic ships several. A lot of small apps do not yet. So MCP is partial: it works great for some workflows, and you still have to copy-paste for others. That gap is closing fast.

Things that surprised me

A few moments that stuck with me, in roughly the order they showed up.

MCP is much smaller than the documentation makes it look

When I read the official spec, my eyes glazed over. JSON-RPC, capability negotiation, transport layers. It sounded like the kind of thing you need a team to adopt. In practice, turning on an MCP server takes about three minutes: install the server, paste a small config file into Claude Code, restart, done. The protocol is heavy on paper because it has to be precise. Using it is light.

It changes which apps I notice

I started paying attention to which of my tools shipped MCP servers. Sanity has one, so I built Scribe. Figma has one, so I started asking Claude to make small design changes for me. Gmail and Calendar have them, so I started asking Claude to summarise threads and find meeting times. The apps without MCP servers feel a little slower to use now, the way a phone with a worn battery feels slow. That was unexpected. MCP support quietly became a feature I look for.

The first MCP call I made felt different from any AI moment before it

I asked Claude to draft a blog post and push it to Sanity. I watched it happen in my Studio editor: the document appeared, the fields filled in, an image attached itself. I did not type anything. I did not click anything. The feeling was not wow, the AI is smart. It was oh, I just delegated a chore. That is a different feeling, and it is the one that made me stop reading about MCP and start using it.

The boring parts are the load-bearing ones

What makes MCP useful is not the model getting smarter. It is that the AI now has a predictable way to ask what can this app do and a predictable way to ask please do it. Those two questions, answered consistently across every tool, is what turns a chat assistant into a coworker. It is the boring part. It is also the part that makes everything else possible.

When is MCP worth paying attention to?

If you use AI assistants for work and feel like the answer is good but the last-mile delivery is slow, MCP is the bridge. It is worth paying attention to right now. Not because the protocol itself is exciting, but because the apps you already use are picking it up, and the gap between AI knows and AI does is closing inside your existing tools.

If you do not yet use AI assistants for anything, MCP is not where I would start. Start by using a chat assistant the boring way for a week. Notice the chores you keep doing yourself after the AI answers. Those chores are the ones MCP removes when the right app supports it.

The piece that surprised me most, after a few months of this: the protocol is not the thing. The thing is the moment when a tool you already use grows a small AI can reach in here badge, and the chore goes away. MCP is what makes that badge possible. The badge is what changes how you work.

I would tell anyone curious about it the same thing I would tell someone about USB-C. Do not think of it as a feature. Think of it as the moment everything stopped needing its own cable.