Why MCP is dead & How I vibe now

Key Concepts

• MCP (Model Context Protocol): A standard protocol for connecting AI agents to external tools and data sources.
• Agent Skills: A modular approach where specific capabilities are defined in .md (Markdown) files, injected into the agent's context only when needed.
• CLI (Command Line Interface): A text-based interface used to execute tools and scripts, serving as a lightweight alternative to traditional MCP tool integration.
• Token Consumption: The amount of data (measured in tokens) an AI model processes; reducing this is critical for performance and cost-efficiency.
• MCP Porter: An open-source tool that allows users to run MCP servers directly via the command line.

---

1. The Problem: Context Window Bloat

Traditional MCP integration requires loading the entire JSON schema and tool definitions of an MCP server into the agent's context window, regardless of whether those tools are relevant to the current task. This leads to:

• Unnecessary Token Consumption: Significant portions of the context window are wasted on unused tool definitions.
• Scalability Limits: Adding hundreds of integrations becomes impossible as the context window fills up with static tool metadata.

2. The Solution: Skills + CLI Framework

The proposed methodology replaces bulky MCP tool definitions with a "Skills + CLI" approach.

• Mechanism: Instead of loading all tools, the agent is provided with a skill.md file. This file contains a brief prompt snippet and a list of resources.
• Efficiency: Each skill adds only 10–50 tokens to the context window. This allows for thousands of integrations within the same space that previously held only a few MCP tools.
• Execution: When an agent needs a specific capability, it triggers a CLI command. This command executes the logic externally, returning only the necessary output to the agent.

3. Step-by-Step Implementation

1. Define the Skill: Create a skill.md file containing instructions on when to retrieve the skill and a description of the available CLI commands.
2. Utilize MCP Porter: Use the MCP Porter tool to bridge existing MCP servers to the CLI.
   • Example: Instead of loading a full "Context 7" MCP, use npx mcp-porter context-7 resolve-library-id [parameters].
3. Modularize Tools: Follow the "Manis" approach:
   • Fundamental Tools: Keep core capabilities (read/write/edit files) loaded as standard tools.
   • Extended Tools: Move infrequent or specialized tools into CLI commands triggered by skills.
4. Automate Onboarding: Create a "Master Skill" (e.g., add-new-mcp) that contains instructions for the agent to automatically install new MCP servers, create the corresponding skill.md files, and update the configuration.

4. Real-World Application: Agent Browser

The video highlights a comparison between a standard Chrome MCP and an "Agent Browser" CLI:

• Standard MCP: Loads multiple tools (click, drag, type, scroll), consuming ~2% of the context window.
• CLI Approach: Uses a dedicated CLI package that returns optimized, structured page data.
• Result: The CLI approach left 117,000 tokens available, compared to 87,000 with the standard MCP—a 70% reduction in token consumption.

5. Key Arguments and Perspectives

• Token Efficiency as a Priority: The speaker argues that developers should migrate away from direct MCP tool loading toward skill-based CLI execution to maximize the "effective context window."
• Power of Piping: CLI tools allow for more complex workflows, such as piping the output of one command into another or using system functions like wait, which are difficult to achieve with standard MCP tool calls.
• Scalability: By treating tools as "skills" that are only called when needed, agents can handle hundreds of integrations without performance degradation.

6. Notable Quotes

• "Every MCP server you add comes with this bundle of different tools... it just unnecessarily eats up loads of context window."
• "This bash plus CLI tool just provides so much more freedom about how an agent can execute tasks."

7. Synthesis and Conclusion

The transition from standard MCP tool integration to a Skill + CLI architecture represents a paradigm shift in agent development. By utilizing tools like MCP Porter and structuring capabilities into modular Markdown-based skills, developers can drastically reduce token overhead (by up to 70%) while simultaneously increasing the number of integrations an agent can manage. This approach not only optimizes the context window but also enables more complex, multi-step automation through CLI piping and specialized command execution.