MCP protocol adoption — six months in, what actually shipped

Anthropic”s Model Context Protocol launched in late November 2024. By early September 2025 — roughly nine-and-a-half months later (the “six months” of the original article framing turned out to be a slight understatement) — MCP had crossed from niche developer-tool detail into the canonical way AI assistants connect to external tools. IndyDevDan”s August 25 video — “5 Agent PATTERNS to SIMPLIFY Your Agentic Coding (Claude Code, Gemini CLI, MCP)” — listed MCP as one of the foundational primitives. By mid-2025, “use the right MCP servers” was as standard advice as “use git.”

The community reaction matters more than the protocol”s technical specification. The r/mcp subreddit grew to substantial activity through 2025, and the community sentiment by mid-2025 was a clarifying mix of enthusiasm and skepticism. The “I spent 3 weeks building my dream MCP setup and honestly, most of it was useless” thread (693 upvotes, Aug 6) captured the maturation: engineers had moved past “everything must be MCP” and into “use MCP where it earns its keep, skip it where it doesn”t.”

This piece is the working assessment from tracking the MCP ecosystem across personal use, projects, and community through 2025.

What MCP actually is

MCP is a protocol for connecting AI assistants to external tools and data sources. Anthropic published the spec in November 2024; Claude Code shipped with native MCP support; other clients (Cursor, Continue, Cline, custom integrations) added support through Q1-Q2 2025.

The architecture:

• MCP server: runs in a separate process; exposes tools (functions the AI can call) and resources (data the AI can read)
• MCP client: the AI assistant (Claude Code, Cursor, etc.) that connects to one or many servers
• Protocol: standardized JSON-RPC over stdio or HTTP

The pitch in November 2024: standardize what every AI assistant was hand-rolling — connecting to filesystems, databases, APIs, specialized tools. By mid-2025 the pitch had largely been validated. Multi-vendor adoption happened; the ecosystem of MCP servers exploded.

What actually shipped: ecosystem snapshot

By September 2025:

Anthropic”s blessed servers (run as MCP servers, well-maintained):

• filesystem, git, github, sqlite, postgres, fetch, brave-search, sentry, slack, sequential-thinking, time, …

Community-built servers with substantial usage:

• playwright (browser automation, covered in the 4-layer skill piece)
• linear (project management integration)
• notion (workspace integration)
• figma (design / asset access — see r/mcp Figma thread)
• bigquery, snowflake, redshift (data-warehouse access)
• jira, confluence (Atlassian)
• aws, gcp (cloud provider tools)
• Hundreds more, varying quality

Vendor-shipped MCP support:

• Claude Code (native, default)
• Cursor (via custom MCP config)
• Continue.dev (via config)
• Cline (via config)
• Some VS Code extensions
• Custom integrations via official SDKs

The donation to the Linux Foundation (covered separately in MCP donated to Linux Foundation) in late 2025 marked the formal transition from “Anthropic-led project” to “open standard.”

The “5 most useful MCP servers” consensus

The r/mcp “My 5 most useful MCP servers” thread (469 upvotes, July 21) captured the pragmatic working set most engineers converge on:

The recurring 5 (across multiple “best MCP” threads through 2025):

1. filesystem — read/write project files (the default)
2. git — git operations
3. github (or gitlab) — issue/PR creation, search
4. fetch — HTTP requests for web research
5. postgres (or whatever your DB is) — direct DB queries

Beyond these 5, the marginal value drops sharply. Most “look at all the MCP servers I”ve installed” lists in r/mcp threads have 15-30 servers; the practitioners report using 3-5 in practice.

The “3 weeks dream setup mostly useless” lesson

The r/mcp 693-upvote thread (Aug 6) is the most honest MCP discourse from 2025. OP spent 3 weeks setting up an elaborate MCP configuration. The lesson:

Most MCP servers aren”t useful for most users. The exceptions:

• The 3-5 above that everyone needs
• Domain-specific servers (Figma for designers, BigQuery for data engineers, Linear for engineering managers)
• Project-specific servers you build for your own workflow

The MCP failure mode: installing 20 servers that the agent could call but never does. The servers consume token budget for tool descriptions, add cognitive overhead, and provide near-zero value because the agent doesn”t actually invoke them.

The pattern: install MCP servers reactively, not proactively. When you find yourself manually doing X across many sessions, add the MCP server for X. Don”t install a server “in case I need it.”

The Figma / design-tooling moment

The r/mcp “Claude Code + Figma MCP is the way” thread (584 upvotes, July 8) captured one of the most consequential 2025 MCP wins. Frontend engineers using Claude Code + Figma MCP can read design specs, extract assets, generate components from Figma frames directly. The workflow that used to require “open Figma, copy specs, paste into Cursor” became a single agent action.

The slightly hyperbolic title — “It”s been nice knowing you frontend devs” — overstates the displacement effect but captures the productivity unlock. For frontend work that depends on design-to-code translation, Figma MCP is a meaningful step change.

The “Protocol Engineering” framing

The r/ClaudeAI “Forget Prompt Engineering. Protocol Engineering is the Future” thread (316 upvotes, July 4) captured the broader shift. The 2024 era of “the prompt is the product” is giving way to “the protocol + tool integration is the product.” MCP is the substrate; the engineering work is in tool design, schema design, and orchestration patterns.

IDD”s “Elite Context Engineering” (Sep 8) and his Hooks video (Jul 7) extend the pattern: the highest-leverage work in 2025 is context + tool integration, not raw prompt crafting. MCP is the infrastructure that makes context-engineering scalable across team and projects.

The “local-first MCP” subset

The r/mcp “simplest way to use MCP, all local, 100% open source” thread (506 upvotes, July 11) captured the privacy-conscious / offline pattern. MCP works fully local with Ollama-hosted models + local-only MCP servers. For sensitive codebases or air-gapped environments, the MCP architecture preserves the benefits without the cloud dependency.

This is one of MCP”s underrated wins: the protocol is the same whether you”re hitting Anthropic”s hosted Claude or a local Qwen via Ollama. The MCP server doesn”t care; the workflow patterns transfer.

The “tired of explaining the same shit” pattern

The r/ClaudeAI thread “I got tired of explaining the same shit to Claude every session so I built this” (191 upvotes, July 23) is the canonical MCP origin story. Engineers building custom MCP servers to handle “the same context I”ve explained 50 times” is now the dominant pattern. Whether it”s “tell Claude about my deployment pipeline” or “give Claude access to our internal API docs” — custom MCP servers are the cleanest way to embed that context once.

Creator POV vs Reddit dissent

The creator landscape through 2025 increasingly emphasizes MCP as foundational. IDD, Theo, Fireship — all cover MCP as essential infrastructure. “Use MCP” is now as common advice as “use git.”

The Reddit dissent splits productively:

The pro-MCP majority — vocal in r/mcp, r/ClaudeAI. MCP is the substrate; protocol engineering is the new prompt engineering.

The “MCP is over-engineered for simple cases” camp — accurate for casual use. If you”re using Claude Code for personal scripts, you probably need 0-1 MCP servers, not 10.

The “MCP fragmentation is coming” camp — predictive. Multiple vendors implementing MCP means multiple slightly-different implementations. Real concern; partly mitigated by the Linux Foundation donation.

The “protocol vs framework” debate — some users argue MCP would be better as a framework (LangChain-style) than a protocol. Counter: protocols compose better than frameworks; MCP”s simplicity is the feature.

What this means for working engineers in early September 2025

Three concrete positions:

1. If you”re using Claude Code or any MCP-supporting client, install the 5 standard MCP servers (filesystem, git, github, fetch, postgres or your DB). Foundation.

2. Add domain-specific servers reactively, not proactively. When you notice yourself doing X manually across sessions, find or build the MCP server for X. Don”t install servers speculatively.

3. Treat MCP server discovery as ongoing infrastructure work. The ecosystem is fast-moving; new useful servers appear monthly. Allocate time quarterly to refresh your stack.

The honest critique

What this analysis can”t address:

• MCP performance has rough edges. Some servers add meaningful latency; some are buggy; troubleshooting “why is Claude not calling this tool” is annoying.
• The security model is light. MCP servers run with your credentials; a malicious or compromised server has broad access. Audit before installing.
• Multi-vendor implementations diverge in details. Claude Code”s MCP integration vs Cursor”s vs Continue”s have subtle differences. Test your specific stack.
• The “kitchen sink” anti-pattern is real. Installing many servers without discipline degrades agent performance via tool-description noise.

For most working engineers reading this in early September 2025: MCP is foundational infrastructure for AI-assisted work, the ecosystem has matured into a real teachable thing, and the protocol-engineering discipline is the highest-leverage skill in the AI tools category. Install the basics, build out reactively, treat it as infrastructure.

For broader Claude Code workflow context, see our Personal Claude Code workflow guide, Claude Code first-month dominance analysis, and the MCP donated to Linux Foundation piece for the governance transition story.