Cómo funcionan juntos Skills, Agentes y Servidores MCP en Claude Code

Probablemente te has topado con este muro antes: pegas toda tu base de código en un chat de IA, añades un prompt detallado, y recibes... nada útil. O peor aún, el modelo empieza a alucinar nombres de funciones que no existen porque perdió el rastro de lo que leyó hace 50,000 tokens.

Este es el problema de la ventana de contexto. Y es por eso que lanzarle más código a un LLM no lo hace más inteligente.

Claude Code resuelve esto de manera diferente. No teniendo una ventana de contexto más grande (aunque eso ayuda), sino siendo inteligente sobre cómo usa el espacio que tiene. Lo hace a través de tres cosas trabajando juntas: skills, sub-agentes y servidores MCP.

Déjame mostrarte cómo encajan estas piezas. Una vez que entiendas esto, dejarás de pelear con la IA y empezarás a trabajar con ella.

El problema de la ventana de contexto

Aquí hay algo que me tomó un tiempo interiorizar: los LLMs no "recuerdan" realmente el inicio de una conversación larga como esperarías. La ventana de contexto es más como un foco de luz que como un archivero. A medida que añades más tokens, el contenido anterior recibe menos atención. Pega 100,000 tokens de código, y el modelo básicamente está hojeando para cuando llega a tu pregunta.

Esto explica mucho del comportamiento frustrante de la IA. El modelo parece inteligente al principio, luego se confunde. Olvida cosas que le dijiste antes. Alucina detalles de archivos que "leyó" pero claramente no retuvo.

La solución no es una ventana de contexto más grande. La solución es no necesitar una.

Cómo piensa realmente Claude Code

Claude Code es un agente. Eso suena elegante, pero solo significa que puede planificar, ejecutar, observar resultados e iterar. Cuando le pides que "arregle las pruebas que fallan en mi proyecto", no intenta entender toda tu base de código de una vez. En cambio, trabaja en pasos enfocados:

1. Lee la estructura del proyecto para entender qué está dónde
2. Ejecuta las pruebas para ver qué está fallando realmente
3. Mira la prueba específica que falla y el código que prueba
4. Hace una corrección
5. Ejecuta las pruebas de nuevo
6. Si aún está roto, intenta algo más

Cada paso trabaja solo con el contexto que necesita. El agente mantiene un resumen funcional de lo que ha aprendido, no un registro crudo de todo lo que ha visto. Así es como Claude Code puede iterar 20 veces en un bug complejo sin quedarse sin espacio de contexto.

Piénsalo como realmente depurarías algo. No mantienes toda tu base de código en tu cabeza. Te enfocas en un área, formas una hipótesis, la pruebas y ajustas. Claude Code funciona de la misma manera.

Sub-agentes: el verdadero cambio de juego

Aquí es donde se pone realmente interesante. Claude Code puede generar sub-agentes.

Un sub-agente es una instancia separada de Claude con su propia ventana de contexto limpia. Puedes decirle a Claude Code que genere uno, darle una tarea enfocada, dejarlo trabajar independientemente y recibir un resumen de lo que encontró. El contexto completo del sub-agente nunca contamina tu conversación principal.

Esto es enorme. En lugar de un agente tratando de sostener todo:

Tú: "Analiza esta base de código en busca de problemas de seguridad, problemas de rendimiento y cobertura de pruebas"

El agente principal genera sub-agentes: ├── Sub-agente 1: Análisis de seguridad (contexto propio, lee archivos relevantes de seguridad) ├── Sub-agente 2: Revisión de rendimiento (contexto propio, se enfoca en rutas críticas)
└── Sub-agente 3: Cobertura de pruebas (contexto propio, examina archivos de prueba)

Cada sub-agente devuelve un resumen al agente principal El agente principal sintetiza todo en una respuesta

Los sub-agentes pueden leer miles de líneas de código cada uno. Pero el agente principal solo recibe sus hallazgos condensados. Tu contexto principal se mantiene limpio mientras obtienes análisis profundo en múltiples áreas.

Piénsalo como delegar a desarrolladores junior. No necesitas leer cada línea que revisaron. Necesitas sus conclusiones y cualquier señal de alerta que encontraron. Los sub-agentes funcionan de la misma manera.

Cómo usar realmente los sub-agentes

Puedes pedirle explícitamente a Claude Code que genere un sub-agente:

• "Genera un sub-agente para analizar el módulo de autenticación en profundidad"
• "Usa un sub-agente para revisar todas las consultas de base de datos en busca de problemas N+1"
• "Haz que un sub-agente revise los archivos de prueba y reporte sobre brechas de cobertura"

El sub-agente obtiene su propio contexto fresco, hace el trabajo profundo y devuelve un resumen. Tu conversación principal no se infla con todo el análisis crudo.

Esto es especialmente poderoso para bases de código grandes. En lugar de que Claude Code pierda el rastro de las cosas a mitad de camino, obtienes análisis enfocado que realmente escala.

Dónde entran los Skills

Entonces Claude Code puede desglosar tareas, generar sub-agentes y trabajar en pasos enfocados. ¿Pero cómo sabe cómo hacer cosas específicas bien? Ahí es donde entran los skills.

Los skills son instrucciones empaquetadas que Claude lee antes de abordar tipos específicos de tareas. Cuando le pides a Claude Code que cree una presentación de PowerPoint, primero lee el archivo de skill en /mnt/skills/public/pptx/SKILL.md. Este archivo contiene mejores prácticas, errores comunes y patrones de código exactos que realmente funcionan.

Un skill típicamente incluye:

• Un archivo SKILL.md con instrucciones detalladas
• Plantillas de código y ejemplos
• Limitaciones conocidas y soluciones alternativas
• Especificaciones de formato de salida

La idea clave es que los skills se cargan bajo demanda. Claude no desperdicia espacio de ventana de contexto en instrucciones de PowerPoint cuando estás depurando Python. Carga el skill relevante cuando lo necesita, usa esa experiencia para la tarea y continúa.

Esto es diferente de las herramientas. Las herramientas son funciones que Claude llama para obtener datos de vuelta, como web_search o bash_tool. Los skills son paquetes de conocimiento que cambian cómo Claude aborda los problemas. La distinción importa porque las herramientas cuestan tokens en el prompt del sistema (más herramientas = menos espacio para tu código), mientras que los skills se cargan solo cuando son relevantes.

Los sub-agentes también pueden cargar skills. Un sub-agente analizando seguridad puede cargar skills específicos de seguridad sin que esas instrucciones saturen tu conversación principal.

El bucle de iteración

Un patrón que verás constantemente es el bucle de iteración. Claude Code genera algo, verifica si funciona y corrige problemas hasta que esté bien.

1. Genera código
2. Lo ejecuta (o lo analiza con lint, o verifica tipos)
3. Ve si funciona
4. Si no, analiza el error e intenta de nuevo
5. Repite hasta que pase

Por esto es que Claude Code puede arreglar bugs que un prompt de un solo intento perdería. No solo está generando código y esperando. Está probando su propio trabajo y respondiendo a retroalimentación real.

Cuando Claude Code crea un componente React y luego ejecuta el servidor de desarrollo para verificar errores, está usando este bucle. Cuando escribe una función y ejecuta las pruebas para verificar que funciona, lo mismo. Los pasos de generación y verificación trabajan juntos.

Esto también explica por qué Claude Code a veces toma más tiempo del que esperarías. No es lento. Es minucioso. Está ejecutando tus pruebas, verificando errores de tipo e iterando hasta que las cosas realmente funcionen.

Servidores MCP: conectando a sistemas externos

Hasta ahora hemos hablado sobre cómo piensa Claude Code (pasos agénticos, sub-agentes) y qué sabe (skills). ¿Pero qué hay de conectarse a sistemas externos? Ahí es donde entra MCP.

El Model Context Protocol es cómo Claude Code habla con bases de datos, GitHub, sistemas de archivos, pipelines de CI/CD y prácticamente cualquier otra cosa. Piensa en MCP como USB-C para IA: una interfaz estándar que permite que cualquier sistema de IA compatible se conecte a cualquier servicio compatible.

Los servidores MCP exponen tres tipos de capacidades:

Herramientas: funciones que Claude puede llamar, como consultar una base de datos o crear un pull request

Recursos: fuentes de datos que Claude puede leer, como contenidos de archivos o esquemas de base de datos

Prompts: plantillas reutilizables para interacciones comunes

Para desarrollo web, los servidores MCP más útiles incluyen:

• Servidor de sistema de archivos: lee y escribe archivos en tu proyecto (en sandbox por seguridad)
• Servidor de GitHub: gestiona repos, PRs, issues y workflows
• Servidores de base de datos: consulta PostgreSQL, MySQL, SQLite a través de lenguaje natural

Así se ve un servidor MCP simple en TypeScript: typescript import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new McpServer({ name: 'code-analyzer', version: '1.0.0' });

server.registerTool( 'analyze_complexity', { description: 'Analyze cyclomatic complexity of a file', inputSchema: { filePath: { type: 'string' } } }, async ({ filePath }) => { const result = await analyzeFile(filePath); return { content: [{ type: 'text', text: JSON.stringify(result) }] }; } );

const transport = new StdioServerTransport(); await server.connect(transport);

El poder de los servidores MCP viene de cómo funcionan con los sub-agentes. Un sub-agente puede consultar una base de datos a través de MCP, analizar miles de filas y devolver solo los hallazgos relevantes. Los datos crudos nunca tocan tu contexto principal.

Juntando todo

Veamos un ejemplo real. Le pides a Claude Code: "Revisa este PR y verifica si las migraciones de base de datos son seguras."

Esto es lo que realmente sucede:

1. El agente principal carga skills relevantes para revisión de código
2. Genera un sub-agente para analizar los cambios del PR en profundidad
3. Ese sub-agente llama al servidor MCP de GitHub para obtener detalles del PR
4. Otro sub-agente lee archivos de migración y consulta el esquema actual de base de datos a través de MCP
5. Los sub-agentes devuelven resúmenes enfocados: "La migración añade índice, se ve segura" o "Advertencia: esto elimina una columna que aún está referenciada"
6. El agente principal sintetiza los hallazgos de los sub-agentes en una respuesta clara

Observa cómo el trabajo pesado ocurre en sub-agentes con sus propios contextos. El agente principal orquesta y resume. Tu conversación se mantiene limpia mientras obtienes análisis profundo.

Por qué esto importa para tu flujo de trabajo

Entender esta arquitectura cambia cómo trabajas con Claude Code:

Dejas de pelear con la ventana de contexto. Una vez que te das cuenta de que los sub-agentes manejan el análisis profundo por separado, dejas de intentar pegar toda tu base de código en la conversación principal. Deja que los sub-agentes hagan la lectura pesada.

Usas explícitamente sub-agentes para tareas grandes. En lugar de esperar que Claude Code lo descubra, dile: "Usa un sub-agente para analizar el módulo de pagos" o "Genera sub-agentes para revisión de seguridad, rendimiento y pruebas". Estás trabajando con la arquitectura en lugar de contra ella.

Entiendes por qué algunas tareas funcionan mejor que otras. Las tareas que pueden delegarse a sub-agentes escalan genial. Las tareas que requieren ida y vuelta constante en un contexto alcanzan límites más rápido.

Confías en el bucle de iteración. Al arreglar bugs, deja que Claude itere. A menudo encontrará problemas que no anticipaste al realmente ejecutar el código y observar fallas. No lo interrumpas después del primer intento.

Consejos prácticos

Pide explícitamente sub-agentes en tareas grandes. "Genera un sub-agente para revisar el sistema de autenticación" funciona mejor que esperar que Claude Code descubra que necesita delegar.

Deja que Claude lea skills primero. Si estás creando documentos o trabajando con formatos de archivo específicos, Claude se desempeña mejor cuando lee el archivo de skill relevante antes de comenzar.

Conecta servidores MCP para integraciones repetitivas. En lugar de copiar y pegar salidas de base de datos o detalles de PRs de GitHub en tus prompts, conecta los servidores MCP relevantes. Claude extrae exactamente lo que necesita.

Revisa el ecosistema antes de construir herramientas personalizadas. El ecosistema MCP ha crecido a más de 5,000 servidores comunitarios cubriendo Stripe, Cloudflare, sistemas CI y la mayoría de servicios que querrías integrar. Alguien probablemente ya construyó lo que necesitas.

Da retroalimentación cuando esté equivocado. Cuando Claude Code produce resultados incorrectos, dile qué salió mal. El bucle de iteración funciona para tu retroalimentación también.

El panorama general

MCP fue recientemente donado a la Linux Foundation, con OpenAI, Google y Microsoft uniéndose como miembros de apoyo. Esto señala que el protocolo se está convirtiendo en infraestructura estándar de la industria, no solo algo de Anthropic.

La combinación de sub-agentes (trabajo paralelo en contextos separados), skills (experiencia de dominio cargada bajo demanda) y servidores MCP (conexiones limpias a sistemas externos) representa cómo funcionan realmente los asistentes de codificación con IA modernos. No es magia. Es buena arquitectura resolviendo restricciones reales.

El patrón de sub-agentes especialmente vale la pena entenderlo profundamente. Es la diferencia entre una IA que se ahoga en bases de código grandes y una que escala. Cuando le pides a Claude Code que analice algo grande, no está metiendo todo en un contexto y rezando. Está delegando a sub-agentes enfocados, cada uno con contexto limpio, y sintetizando sus hallazgos.

Entender estas piezas te ayuda a trabajar con el sistema en lugar de contra él. Obtendrás mejores resultados, chocarás con menos muros y sabrás cuándo confiar en la IA versus cuándo tomar el control manualmente.