MCP Is Dead (Here’s the Skills Replacement)

Skills in AI Agents: A Deep Dive

Key Concepts:

• Skills: Reusable, on-demand instructions and scripts for AI agents to perform specific workflows efficiently. Often involve code execution.
• MCPs (Managed Code Pipelines): Standardized way to access external systems (Google Drive, Slack, etc.). Skills can utilize MCPs but aren’t replacements.
• Tool Calling: Direct invocation of specific tools for simple tasks. Skills are for more complex, multi-step workflows.
• Workflow: A sequence of steps, data transformations, and iterations required to achieve a specific outcome. Skills excel at handling workflows.
• Token Bloat: The cost of including numerous tools in an agent’s context window, even if unused. Skills reduce this by loading only necessary code.
• Model Distillation: Using a powerful model (like Claude Opus) to create a skill that can then be used by a smaller, more efficient model.

I. The Problem with Traditional Agent Building

The speaker began by detailing initial failures when attempting to build a deck-generating agent using a standard approach with hard-coded tools. The output was disorganized and lacked consistent layout. The core issue was constraint – the agent was limited by the narrow functionality of the available tools. This led to the realization that providing the agent with a single code execution tool and allowing it to generate slides directly through open-ended code dramatically improved results. Saving the successful code as a “skill” allowed subsequent runs to start from a working foundation, reducing token usage and improving consistency. As the speaker stated, “Skills are the layer that makes agents compound instead of starting from scratch every single time.”

II. Defining Skills: What They Are and Aren’t

Skills are defined as reusable, on-demand instructions and scripts that enable agents to efficiently execute specific workflows. Crucially, skills aren’t constantly present in the agent’s prompt; they are invoked only when needed, residing as separate files (like folders in a repository). Each skill folder contains the necessary instructions and, often, code for a particular task.

Skills are not replacements for MCPs. MCPs remain the easiest way to connect agents to external systems. Similarly, skills don’t replace function calling for simple, single-action tasks. If an agent needs to submit a Jira ticket or fetch a customer record, a standard tool call is more reliable. The real power of skills emerges when dealing with complex workflows involving multiple steps, edge cases, data transformations, or the generation of artifacts like documents, spreadsheets, or presentations. Traditional tool calling falters in these scenarios due to the limited scope of most available tools. The speaker highlighted that “the moment the user asks for something outside of that narrow set, the agent can't do it.”

III. Skills vs. Tools & MCPs: A Hierarchical View

The speaker presented a clear diagram illustrating the relationship between code, tools, MCPs, and skills. At the base is code – everything ultimately relies on code. Tools and MCPs are simply code wrapped in callable interfaces. MCPs provide a standardized way to access external tools. Skills, however, operate on a separate axis. They are workflows that utilize code and potentially tools/MCPs to achieve a result. Skills can be primarily code-driven, tool-centric, or a combination.

IV. The Benefits of Using Skills

The speaker outlined four key benefits of adopting a skills-based approach:

• Increased Autonomy & Flexibility: Agents aren’t constrained by rigid tool schemas and can adapt during workflow execution.
• Reuse: Successfully completed workflows are saved as skills, eliminating the need to reinvent solutions.
• Cost Reduction: While initial workflow exploration might be token-intensive, subsequent runs using saved skills are significantly cheaper. The speaker cited a 10x reduction in token usage in their 2,000 tools agent experiment – from 76,000 to 8,000 tokens after saving as a skill.
• Consistency: Skills ensure that generated outputs (docs, sheets, decks) adhere to a consistent structure and layout.

V. Trade-offs and Safety Considerations

While powerful, skills introduce trade-offs. Debugging can be more challenging as traces often show large blocks of code, making it difficult to pinpoint errors. Safety is also a concern, as skills involve open-ended code execution. However, the speaker argued that this risk isn’t fundamentally different from using MCPs with potentially destructive capabilities. The recommended mitigation strategy is to restrict the agent’s ability to modify the skills directory, ensuring that all skills are reviewable and version-controlled. “Agents can use skills, but they cannot modify the skills directory themselves.”

VI. Building Skills: A Practical Demonstration

The speaker demonstrated building skills using Claude and Codex. They highlighted that ChatGPT has already begun adopting skills internally, indicating their growing importance. The standard skill structure, inspired by Anthropic, involves a skill.md file containing the skill’s name, description, and instructions, along with supporting script files.

The speaker used the “skill creator skill” available in the Anthropic skills GitHub repository to generate a skill for building AI agents using their framework. The process involved providing detailed documentation and a workflow MTC file to Claude. The resulting skill included scripts for setting up directory structures and initializing the agency.

The skill was then installed in Codex, and a virtual assistant agent was created to utilize skills from ChatGPT. The agent successfully generated a deck comparing GPT-4o and Gemini Nano, and a workforce planning model spreadsheet, demonstrating the practical application of skills.

VII. Model Distillation & Future Implications

The speaker touched upon the concept of model distillation, where a powerful model like Claude Opus can be used to create skills that can then be deployed with smaller, more efficient models. This allows for leveraging the capabilities of larger models without the associated computational costs.

Data & Statistics:

• Token Reduction: 10x reduction in token usage (from 76,000 to 8,000) after saving a workflow as a skill.
• 2,000 Tools Agent Experiment: Demonstrated the benefits of skills in a complex agent setup.

Conclusion:

Skills represent a significant advancement in AI agent development, enabling greater autonomy, reusability, cost-effectiveness, and consistency. By moving beyond simple tool calling and embracing code-driven workflows, developers can create agents capable of tackling complex tasks and generating high-quality outputs. While safety and debugging require careful consideration, the benefits of skills outweigh the risks when implemented with appropriate safeguards. The adoption of skills by platforms like ChatGPT signals a shift towards this more powerful and flexible approach to agent building.