Garry Tan Was Right: "MCP Sucks Honestly." I Have the Token Receipts.
"MCP sucks honestly. Context window eats too much, auth is a mess. I wrote a CLI wrapper in 30 minutes and it works better."
When YC's CEO Garry Tan declared on X that "MCP sucks honestly," it resonated with a developer community quietly grappling with the protocol's limitations. While Tan's statement provided a high-profile validation, the underlying issues—context window bloat and authentication complexities—have been simmering. Now, evidence from developer experiences and internal company decisions is starting to surface, substantiating the critique.
The Growing Chorus Against MCP
Tan's public commentary was not an isolated incident. Over the past six months, a series of high-profile statements and actions have signaled a growing dissatisfaction with MCP. Peter Steinberger, founder of OpenClaw, publicly stated, "mcp were a mistake. bash is better." This sentiment gained further traction when Eric Holmes' article, "MCP is dead. Long live the CLI," hit the front page of Hacker News, indicating widespread developer agreement. The most concrete signal, however, came from Denis Yarats, CTO of Perplexity, who announced that the company is replacing MCP with a combination of REST API and CLI internally. This move by a prominent AI research and product company suggests a pragmatic pivot away from MCP for core workflows.
The common threads in these criticisms point to specific technical shortcomings. The "context window eats too much" complaint refers to how MCP handles data, potentially leading to inefficient processing and increased computational costs. The "auth is a mess" issue highlights difficulties in securing and managing access to resources or data mediated by MCP. These aren't minor bugs; they are fundamental challenges impacting developer productivity and system efficiency.
Developer Experiences: The "Token Receipts"
The author of the original post on dev.to provides what they term "token receipts"—personal anecdotes and practical evidence supporting the critique. The core of the complaint revolves around the overhead introduced by MCP. For instance, the author states that MCP's context window consumes excessive resources, leading to slower performance and higher costs than necessary. This is particularly problematic for developers working with large datasets or high-frequency requests, where efficiency is paramount.
The authentication layer is another major pain point. The author describes it as "a mess," implying a lack of standardization, complexity in implementation, or poor security practices. This forces developers to spend valuable time wrestling with authentication mechanisms rather than focusing on building core application logic. The author's solution—writing a CLI wrapper in 30 minutes that "works better"—underscores the perceived inefficiency of the existing MCP framework. This suggests that a simpler, more direct approach can yield superior results with less effort.
The implications of these issues extend beyond individual developer frustration. For companies, inefficient protocols translate directly into higher operational costs and slower development cycles. When a protocol requires extensive workarounds or custom wrappers, it undermines the very reason for its existence—to simplify and standardize interactions. The fact that a functional alternative could be built in under an hour highlights potential design flaws or an outdated architecture within MCP itself.
The Broader Shift: From Protocol to APIs and CLIs
The dissatisfaction with MCP aligns with a broader trend in software development: a preference for well-defined REST APIs and robust Command Line Interfaces (CLIs). REST APIs offer a standardized, stateless, and scalable way to interact with services, while CLIs provide direct, scriptable access for developers. This combination often proves more flexible and easier to manage than a monolithic protocol that attempts to handle too many aspects of interaction.
Perplexity's internal shift to REST API and CLI is a significant indicator. It suggests that even companies at the forefront of AI development are finding MCP inadequate for their needs. This move isn't just about replacing one tool with another; it's about adopting a more modern, developer-centric approach to service interaction. REST APIs, with their clear contracts and widespread tooling support, and CLIs, with their power for automation and scripting, represent a mature ecosystem that MCP struggles to match.
The criticism of MCP's context window also speaks to the evolving demands of modern applications, particularly in the AI space. As models become more sophisticated and data volumes increase, the efficiency of data handling and context management becomes critical. Protocols that are not optimized for these demands will inevitably fall behind. The comparison to `bash`, as made by Steinberger, suggests a desire for the simplicity and power of shell scripting, which excels at chaining simple, focused tools together—an approach often facilitated by APIs and CLIs.
What's Next for MCP?
The current sentiment and actions suggest a critical juncture for MCP. While it may still be in use in many legacy systems or specific niches, its future as a leading protocol for new development appears uncertain. The voices of influential figures like Garry Tan, coupled with the practical experiences of developers and strategic decisions by companies like Perplexity, build a compelling case against its continued widespread adoption for new projects. If MCP is to remain relevant, it will need to address its fundamental issues with context management and authentication, or risk being superseded entirely by more agile and developer-friendly alternatives.