Why are top engineers DITCHING MCP Servers? (3 PROVEN Solutions)

Detailed Summary

Beyond MCP: The Problem (0:00 - 1:05)

The video introduces the core problem: MCP servers consume a large number of context tokens (e.g., 10,000 tokens, or 5% of an agent's context window) before the agent even begins its task. This "context bleeding" worsens with multiple MCP servers, potentially consuming over 20% of the context. The video promises to explore three proven alternatives used by leading companies and engineers to maintain control and preserve context.

Kalshi Markets MCP Server (1:06 - 3:55)

This section demonstrates the classic MCP server approach using a Kalshi prediction markets agent. The MCP server manages the connection to external data sources, allowing the agent to search markets, retrieve trade data, and analyze market sentiment. While powerful for understanding information quickly, the main drawback is the immediate consumption of a significant portion of the context window (e.g., 10,000 tokens for a relatively small server).

CLI as Tools (3:55 - 11:06)

The CLI approach involves teaching the agent to use command-line interface tools through a specific prompt. This method drops the MCP server, allowing for a cheaper and faster model. A concise 25-line prompt defines how the agent should use the CLI, giving full control over what the agent can and cannot do. This approach reduces context consumption significantly (e.g., from 10% to 5.6%) compared to MCP servers. The CLI works for individual engineers, teams, and agents, making it a versatile solution for building tools.

Scripts as Tools (11:06 - 18:31)

This section introduces scripts as tools, emphasizing "progressive disclosure"—a technique where the agent only loads necessary information. By priming the agent with a readme file that outlines when to use each script, context consumption can be drastically reduced to less than 1% (under 2,000 tokens). This is achieved by prompt engineering the agent not to read the scripts themselves unless specific help is needed. Each script is self-contained, allowing for isolated functionality and better agent performance due to less "garbage context." The video highlights that benchmarks show no degradation in quality compared to MCP servers.

Skills as Tools (18:31 - 22:45)

Skills are presented as another method for context management, similar to scripts but with a different invocation mechanism. The "skill.md" file acts as the priming prompt, defining the skill and its underlying scripts. Skills offer progressive disclosure, consuming minimal context initially (only the skill definition). This approach bundles scripts into a self-contained, isolated directory, providing specific tools without building a full MCP server. While powerful, skills are noted as a Claude-specific ecosystem lock-in mechanism.

Agent Tooling Trade-offs (22:45 - 32:00)

This final section provides a comprehensive comparison of all four approaches (MCP, CLI, Scripts, Skills) across various dimensions:

• Invocation: MCP is agent-invoked; CLI requires a slash command setup; Skills are automatic.
• Context Window Consumption: MCP is the highest; CLI, Scripts, and Skills are significantly lower.
• Customizability: MCP is low (unless owned); CLI, Scripts, and Skills offer full control.
• Portability: MCP is low; CLI is higher; Scripts (single file) and Skills (single directory) are highest.
• Composability: All are composable, but MCP excels with built-in features beyond just tools (resources, prompts, elicitation, completion, sampling).
• Simplicity: MCP is highest; CLI, Scripts, and Skills require more management.
• Engineering Investment: MCP is low for external servers; CLI, Scripts, and Skills require more upfront work.
• Ecosystem Lock-in: MCP is open-source; Skills are Claude-specific lock-in; CLI and Scripts offer full control.

The recommended strategy for external tools is 80% MCP for simplicity, 15% CLI for specific control, and 5% Scripts/Skills for context preservation. For new tools, the recommendation is 80% CLI first (as it works for individuals, teams, and agents), 10% wrapped in MCP for multi-agent scale, and 10% Scripts/Skills for context preservation. The video emphasizes building CLI first to ensure interoperability and ease of wrapping into an MCP server if needed.

Notable Quotes

"10,000 tokens before my agent even started working. That's 5% of my agent's context window gone..." — Indie Dev Dan

"Use raw code as tools." — Indie Dev Dan

"Vitalic calls this info finance. You can use these betting platforms to understand incentives before things happen." — Indie Dev Dan

"Everyone's jumping on the context train. Even before context comes prompt engineering. This is still a critical skill. In fact, it is the critical skill for engineers in 2025 and beyond." — Indie Dev Dan

"Benchmarks have shown that there's no degradation in quality by going right for scripts, going right for CLI, right? basically handing your agent code versus giving them an MCP server." — Indie Dev Dan

"80% of the time, just use MCP servers. Don't think about it. Don't waste your time trying to reinvent the wheel." — Indie Dev Dan

"The problem is when you stack up two or three more larger ones and 20% of my context window is gone. That's a problem." — Indie Dev Dan

"I always build CLI servers instead of MCP servers when I'm building new tools." — Indie Dev Dan

"CLI works for you, your team, and your agents. The trifecta can be met here." — Indie Dev Dan