La Confusión que Todos Tenemos
Cuando empecé a trabajar con agentes IA en Claude, cometí el mismo error que muchos desarrolladores: pensé que MCP era suficiente.
Instalé un servidor MCP, conecté mis herramientas (bases de datos, APIs, sistemas de archivos), y esperé que Claude mágicamente supiera qué hacer con ellas.
No funcionó así.
MCP abrió las puertas. Pero faltaba alguien que supiera cómo caminar por ellas.
Ese alguien es Claude Skills.
Qué Es Realmente MCP
MCP (Model Context Protocol) es un protocolo de comunicación. Piensa en él como un puente entre Claude y tus sistemas externos.
Cuando configuras un servidor MCP, estás diciendo: "Aquí están mis herramientas. Claude puede usarlas si las necesita."
Pero eso es todo lo que hace MCP: proporciona acceso.
No sabe:
- Cuándo usar cada herramienta
- En qué orden ejecutarlas
- Cómo manejar errores o casos especiales
- Cuál es el objetivo real del usuario
Es como tener un Ferrari con el depósito lleno pero sin GPS. Tienes potencia, pero no dirección.
Dónde Entra Claude Skills
Clause Skills es donde escribes la lógica del flujo de trabajo.
Un skill es una unidad de comportamiento que le dice a Claude:
1. Qué problema resuelve (el propósito) 2. Qué herramientas necesita (las dependencias de MCP) 3. Cómo ejecutar el flujo (la lógica paso a paso) 4. Cómo manejar resultados (qué hacer después)
La diferencia es fundamental:
- **MCP**: "Tengo acceso a una base de datos"
- **Skill**: "Necesito consultar la base de datos, filtrar por fecha, transformar los resultados, y enviar un email con el resumen"
Un Ejemplo Real: Monitoreo de Precios
Estoy construyendo un agente que monitorea precios de competidores en tiempo real.
Sin skills, el flujo es caótico:
``` Clause: "¿Qué necesitas?" Usuario: "Monitorea precios de competidores" Clause: *confundido* "Tengo acceso a una API de web scraping... ¿la uso?" ```
Con skills, el flujo es claro:
```javascript // skill-monitor-prices.ts const monitorPricesSkill = { name: "monitor_competitor_prices", description: "Monitorea precios de competidores y alerta sobre cambios", dependencies: [ "mcp-scraping", // Acceso a herramientas de web scraping "mcp-database", // Acceso a almacenamiento de datos "mcp-notifications" // Acceso a sistema de alertas ], execute: async (context) => { // 1. Scrape precios actuales const currentPrices = await context.tools.scrape({ urls: context.competitors, selectors: context.priceSelectors });
// 2. Compara con precios anteriores const previousPrices = await context.db.query( "SELECT * FROM competitor_prices ORDER BY checked_at DESC LIMIT 1" );
// 3. Detecta cambios const changes = detectPriceChanges(currentPrices, previousPrices);
// 4. Guarda en base de datos await context.db.insert("competitor_prices", currentPrices);
// 5. Envía alertas si hay cambios significativos if (changes.length > 0) { await context.tools.sendAlert({ type: "price_change", data: changes }); }
return { changes, timestamp: new Date() }; } }; ```
Ve la diferencia:
- **MCP** proporciona las herramientas (scraping, base de datos, notificaciones)
- **Skill** define el flujo lógico que las conecta
Sin el skill, Claude no sabe que debe hacer esto en este orden específico. Con el skill, es automático.
Cómo Trabajan Juntos en Producción
En mis proyectos actuales, la arquitectura es así:
``` ┌─────────────────────────────────────┐ │ Claude Agent (con claude-sdk) │ ├─────────────────────────────────────┤ │ │ │ ┌──────────────────────────────┐ │ │ │ Skills (Lógica de flujo) │ │ │ │ - monitor_prices │ │ │ │ - generate_reports │ │ │ │ - handle_alerts │ │ │ └──────────────────────────────┘ │ │ ↓ │ │ ┌──────────────────────────────┐ │ │ │ MCP Servers (Herramientas) │ │ │ │ - Scraping API │ │ │ │ - Database Connection │ │ │ │ - Email Service │ │ │ └──────────────────────────────┘ │ │ │ └─────────────────────────────────────┘ ↓ Sistemas Externos ```
Cuando un usuario pide "monitorea precios", Claude:
1. Identifica que existe el skill `monitor_prices` 2. Ejecuta el skill, que orquesta las herramientas de MCP 3. Los servidores MCP hacen el trabajo pesado 4. El skill procesa los resultados 5. Claude devuelve un resumen al usuario
Dónde Muchos Se Equivocan
He visto a desarrolladores cometer estos errores:
Error 1: Dejar toda la lógica en MCP
Intentando que Claude razone sobre qué herramienta usar cada vez. Funciona para casos simples, pero falla en producción cuando hay múltiples pasos o condiciones.
Error 2: Hacer skills demasiado genéricos
Un skill debería resolver un problema específico, no ser un contenedor para "todas las cosas relacionadas con precios". Eso es frágil.
Error 3: No versionear skills
Tus skills cambiarán. Versiónalas como cualquier otra API. Permite que diferentes agentes usen diferentes versiones.
Cómo Empezar
Si estás construyendo un agente IA ahora mismo:
1. Mapea tus herramientas externas → Eso es MCP 2. Define los flujos de trabajo → Eso son skills 3. Empieza con un skill simple → Monitorea, reporta, alerta 4. Itera en público → Construye y comparte lo que aprendes
La combinación de MCP + Skills es poderosa porque separa responsabilidades:
- MCP maneja la **conectividad técnica**
- Skills manejan la **inteligencia del flujo**
Uno sin el otro es incompleto. Juntos, construyes agentes que escalan.
Takeaway
MCP te abre las puertas a tus sistemas. Pero Claude Skills es lo que camina por ellas con propósito. No confundas acceso con inteligencia. Necesitas ambos.
Si estás construyendo agentes IA, empieza aquí: define un skill, conéctalo a MCP, y observa cómo Claude automáticamente sabe qué hacer.
Eso es la diferencia entre una herramienta y un sistema que funciona.
