Yesterday morning I got a text from a friend in tech that said this:

Claude Code, well configured, is a 10xer

I’ve used Claude Code some—and while I’ve found it useful, especially for tasks that involve discovering and navigating multiple files—I wouldn’t say it’s had anything close to a 10x productivity boost for me.

So I asked him what “well configured” meant, and this was his response:

Basically a well written Claude.md, MCP servers for all your tools, and a well defined set of commands Claude should run

If you’re like me—trying to keep up with the latest in development and AI tooling, but also totally overwhelmed by the pace of things—you’ve probably heard people talking about MCP but may not have tried it. This text exchange convinced me to give it a shot, and I spent the last 24 hours learning about MCP and trying to figure out how I can use it to help me write code.

This post covers everything I’ve learned about MCP in the last day—while I still have beginner’s mind. It is by no means a definitive guide to MCP, just one person’s perspective on using it for a day.

TL;DR: MCP is pretty incredible.

What is MCP?

MCP stands for “Model Context Protocol”. It was created by Anthropic and is basically a standard for letting AI assistants work with data and APIs. In the past few months it’s been increasingly adopted by other tools and has emerged as the standard for this use case.

Big picture, MCP operates like a client/server architecture where the clients are LLMs and the servers are tools. Claude (Desktop and Code), and IDEs like Cursor and Windsurf are the most popular clients, though there are others.

Servers “register” with the client through your configuration, and then offer two main capabilities:

1. Discovery: essentially telling the client what tools the server has and how to call them.
2. Tool use: calling the tools and getting back the results.

Then, the client uses LLM magic to determine when one of the server’s capabilities might be a good fit for responding to a prompt, and automatically calls the tool in the appropriate way as needed.

Basically it gives your LLMs new powers!

Note: I don’t know how any of this works under the hood. But I assume you could figure out the details if you read the spec.

MCP Clients

I tried using both Cursor and Claude Code as clients.

My experience was that they could both use tools reasonably well, but Cursor was quite bad at discovery, and I had to nudge it a lot before it would use the tool I wanted it to. It also sometimes used the tool in a dumb way, e.g. failing to inspect the schema of a table before making queries against it, and then giving up when it ran into errors. Cursor MCP support is new, and I’m sure it’ll improve.

Claude Code, on the other hand, was a complete beast—it was great at choosing tools, understanding the order of operations of using them, and delivering the right results.

The rest of these examples will focus on Claude Code, though you could theoretically try these things in any MCP client (I think?).

MCP Servers

MCP servers are basically wrappers around a particular tool. There are tons of MCP servers out there and I only scratched the surface of a few—but once you do that you can see the potential to unlock crazy workflows.

There’s a list of servers here you can start with. Servers can do anything from access your database, connect to SaaS tools like Linear, Github, and Slack, and even control a web browser.

Setting things up

The most wild part of this is just how easy it is to set up. Most of the servers can be run in a single docker, uv, or npx command, and to connect them to a client you just create a JSON file with the arguments needed to run them.¹

Here’s an example that sets up the Postgres server:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://postgres:postgres@localhost:5432/mydb"
      ]
    }
  }
}

Chatting with your database

Once you save that file and restart claude you’ll be prompted to enable the MCP tools:

Claude confirming you want to give it free reign to access your database.

After confirming, you can just start… asking questions!

I connected it to a local copy of my SaaS Pegasus database and just fired away.

Here’s how it handled “how many users are signed up”:

Or “what’s the most popular css framework?”:

On a complete lark, I asked it “Can you generate a plot showing the average duration between signing up and creating your first project?”

And—I shit you not—it one-shotted a Python script that outputted this chart (including coloring and annotations):

This is insane! Companies have invested millions upon millions of dollars inventing “chat with your database” tools, and now you can now build your own with a few lines of JSON!

This entire exchange cost 63 cents by the way.

Controlling a browser

The other fun use case I played with was giving Claude access to my web browser.

You can do that with Microsoft’s playwright server using another four lines of JSON:

{
  "mcpServers": {
    "postgres": { ... },
    "playwright": {
      "command": "npx",
      "args": [
        "@playwright/mcp@latest"
      ]
    }
  }
}

I did two experiments with this.

In the first one I gave Claude a URL that was generating a 500 error in my local app. Claude loaded the page in a browser, read the stack trace, then found and fixed the bug and confirmed the page was working again.

In the second one I intentionally introduced a layout issue on a page and told Claude to find and fix it. Once again, it saw the issue, fixed the bug, and then verified it looked good in the browser. If you want, you can watch that exchange in this video here.

In both of these cases the browser use was more of a gimmick, and I could have fixed the bug faster with my own knowledge. But it was still pretty cool to see it working!

I don’t yet know if I’ll use the browser tool regularly, but it’s fun to have in the toolkit.

MCP and Security

It is worth caveating here that you should definitely only run MCP servers you trust! Any time you let an AI do stuff on your behalf you are taking risks and you need to be comfortable with those risks.

It is quite easy for a malicious tool author to do bad things with MCP without your knowledge.

Conclusion

Overall, this experience really changed my perspective on MCP. I no longer think it is over-hyped. The possibilities that are opened by this really are mind-blowing.

With the right set up, I can see a path to a world where agents find tickets in your issue tracker, fix them, verify the fixes with tests and in a browser, submit pull requests, and do code review. Yes, it won’t work all the time and yes, we’ll want humans in the loop on this for a long time—but the road to the agentic future is now becoming clearer in my mind where before it was pretty hand-wavey. What a world!

MCP is also no longer a scary mystery that I don’t understand. It’s another tool—almost a meta-tool—that I can now reach for whenever I need to give my LLMs new powers.

I hope this post helps some of you to do the same.

Notes: