Skills vs Subagents vs Hooks vs MCP: la guía de decisión de Claude Code (2026)

Si llevas más de una semana usando Claude Code, seguramente ya chocaste con este muro: quieres ampliarlo, abres la documentación y encuentras cuatro mecanismos distintos que suenan todos a "añadir capacidad a Claude" - Skills, Subagents, Hooks y el Model Context Protocol (MCP). Se solapan lo justo para confundir, y nadie te dice cuál elegir. He creado y puesto en producción los cuatro en proyectos reales, así que esta es la guía de decisión que ojalá hubiera existido. Si vas empezando, arranca por qué es Claude Code primero y luego vuelve.

Skills, Subagents, Hooks y MCP de un vistazo

Aquí tienes la tabla de decisión. Cada una de estas cuatro primitivas vive en tu directorio .claude (o en settings.json), y cada una responde a una pregunta distinta de extensibilidad. Repasa por encima las columnas que te importan: qué añade, qué lo dispara, si obtiene su propia ventana de contexto, si es determinista y dónde se configura.

La distinción más nítida de esta tabla: solo los Hooks son deterministas y solo los Subagents obtienen su propia ventana de contexto. Quédate con esos dos hechos y la mitad de la confusión desaparece.

¿Qué es una Skill en Claude Code?

Una Skill es una carpeta con un archivo SKILL.md que guarda instrucciones, listas de verificación o conocimiento de dominio que Claude carga solo cuando es relevante. El mecanismo se llama divulgación progresiva: Claude lee una breve descripción de cada skill al arrancar, pero no trae el cuerpo completo al contexto hasta que decide que la skill se aplica a la tarea en cuestión. Eso significa que una skill casi no cuesta tokens hasta que de verdad se activa. Las Skills pueden invocarse automáticamente por el modelo o dispararse a mano con /skill-name.

.claude/skills/
└── pr-review/
 └── SKILL.md # instructions Claude loads when reviewing a PR

Corrección informativa para 2026: los comandos de barra personalizados ahora están fusionados con las skills. Un antiguo .claude/commands/deploy.md es, en la práctica, la misma idea que .claude/skills/deploy/SKILL.md - muchos artículos antiguos todavía tratan los "commands" como una quinta primitiva aparte, pero la documentación oficial de Claude Code (verificada en 08/2026) los integra en las skills. Así que hay cuatro primitivas que considerar, no cinco.

Recurre a una Skill cuando quieras estandarizar conocimiento o un procedimiento repetible - una convención de código, una lista de revisión, un estilo de la casa para los mensajes de commit. Para un recorrido completo, mira las skills de Claude Code explicadas a fondo. La limitación honesta: una skill es instrucción, no código ni herramienta. Por sí sola no llega a nada fuera de Claude Code - para eso está el MCP.

¿Qué es un Subagent?

Un Subagent es un asistente especializado con su propia ventana de contexto, su propio prompt de sistema, su propia lista de herramientas permitidas y sus propios permisos. Cuando Claude se topa con una tarea que coincide con la descripción de un subagent, la delega: el subagent trabaja de forma independiente en su ventana aislada y devuelve solo un resumen a la conversación principal. Como está aislado, el ruidoso trabajo intermedio - registros, volcados de archivos, callejones sin salida - nunca contamina tu contexto principal. Los Subagents también pueden ejecutarse en modelos más baratos (por ejemplo, Haiku) para mantener asequible el trabajo delegado.

.claude/agents/
└── code-reviewer.md # name, description, tools, model, system prompt

La mejor señal para un subagent: una tarea secundaria inundaría tu contexto principal. Una investigación profunda por decenas de archivos, un análisis largo de registros, una refactorización autocontenida - cualquier cosa en la que solo te importa la conclusión, no el desorden. Aprende a encadenar varios en un flujo de trabajo real de desarrollo con IA usando AgentKit.

El antipatrón honesto: abusar de los subagents quema tokens. Cada delegación levanta un contexto nuevo y reestablece el estado, así que envolver una tarea de dos líneas en un subagent es puro sobrecoste. Úsalos cuando el aislamiento se pague solo.

Un matiz que conviene separar: algunas herramientas de asesoría se ejecutan en línea, como una única llamada de herramienta, y no como un subagent aislado - mira en qué se diferencia la herramienta advisor de un subagent (advisor vs kongming).

¿Qué es un Hook?

Un Hook es un comando de shell determinista que se dispara en un evento del ciclo de vida, configurado en settings.json. A diferencia de las otras tres primitivas, un hook es código, no un prompt - se ejecuta sin importar lo que decida el modelo. Entre los eventos comunes están PreToolUse (antes de que Claude ejecute una herramienta), PostToolUse (después) y Stop (cuando termina un turno). Eso convierte a los hooks en la herramienta ideal para las barreras: formatear y pasar el linter en cada edición, bloquear un comando arriesgado, buscar secretos antes de un commit o lanzar una notificación de escritorio cuando termina una tarea larga.

// settings.json
{
 "hooks": {
 "PostToolUse": [
 { "matcher": "Edit|Write",
 "hooks": [{ "type": "command", "command": "npm run format" }] }
 ]
 }
}

El contraste clave con todo lo demás de esta página: un hook no pide permiso al modelo. Si el evento coincide, se ejecuta - todas y cada una de las veces. Ese determinismo es justo la razón por la que lo usas para cosas que nunca deben saltarse. Mira el análisis a fondo de los fundamentos de Claude Code si los eventos del ciclo de vida te son nuevos. El antipatrón honesto: los hooks que bloquean de forma demasiado agresiva pelearán contigo en trabajo legítimo, así que mantén tus matchers bien ajustados.

¿Qué es el MCP (Model Context Protocol)?

El MCP (el Model Context Protocol) es un estándar abierto que conecta Claude Code con herramientas y fuentes de datos externas a través de servidores MCP. Un servidor expone un conjunto de herramientas - leer un PR de GitHub, consultar una base de datos Postgres, manejar un navegador, llamar a una API interna - y Claude las llama igual que a las integradas. El MCP es lo que estandariza la integración de herramientas, para que no escribas un puente a medida para cada servicio. Los servidores se declaran en .mcp.json.

// .mcp.json
{
 "mcpServers": {
 "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] }
 }
}

La mejor señal para el MCP: necesitas que Claude llegue a un sistema que no controla - tu base de datos, tu gestor de incidencias, una API en vivo. Si te descubres copiando y pegando datos en el chat para que Claude pueda actuar sobre ellos, ese trabajo es de un servidor MCP. El antipatrón honesto: recurrir al MCP cuando bastaría con una Skill sencilla. Si solo necesitas que Claude sepa una convención, eso es una skill; el MCP es para cuando necesita hacer algo en un sistema externo.

Las diferencias de verdad (comparativa lado a lado)

Las definiciones son fáciles; la confusión vive en los solapamientos. Aquí tienes el desglose en los ejes que de verdad separan a los cuatro.

Skill vs MCP es la confusión más común. Una skill añade instrucciones - cambia lo que Claude sabe y cómo se comporta. El MCP añade capacidad - deja que Claude toque un sistema que de otro modo no alcanza. "Sigue nuestra lista de revisión de PR" es una skill; "lee el PR real desde GitHub" es MCP. Con frecuencia trabajan juntos.

Skill vs Subagent es la segunda trampa. Ambos parecen "darle una especialidad a Claude", pero una skill es conocimiento en contexto que el propio modelo principal aplica, mientras que un subagent es un trabajador fuera de contexto que se va y hace el trabajo aislado. Si quieres que el hilo principal se comporte de cierta manera, usa una skill. Si quieres descargar una tarea para que no te llene la ventana, usa un subagent.

Chuleta de dónde se configura cada cosa, todo en un sitio: las skills viven en .claude/skills/, los subagents en .claude/agents/, los hooks en settings.json y los servidores MCP en .mcp.json. Cuatro primitivas, cuatro hogares.

¿Cuándo usar cada una? (decisión por objetivo)

Sáltate la teoría - empieza por lo que intentas hacer. Aquí van frases reales de una línea asignadas a la primitiva correcta:

• Quiero estandarizar un procedimiento repetible (lista de revisión, estilo de commit) → Skill
• Quiero mantener una tarea cargada de investigación o de registros fuera de mi contexto principal → Subagent
• Quiero forzar el formateo, los tests o el escaneo de secretos todas y cada una de las veces → Hook
• Quiero que Claude consulte mi base de datos, abra un PR o llame a una API → MCP
• Quiero una convención de la casa que Claude siga siempre → Skill
• Quiero una refactorización grande hecha sin mirar el ruido intermedio → Subagent
• Quiero bloquear un comando peligroso antes de que se ejecute → Hook

Fíjate en el patrón: el conocimiento y el comportamiento se inclinan hacia las Skills, el aislamiento hacia los Subagents, la imposición innegociable es siempre Hook, y cualquier cosa que cruce la frontera de tu app es MCP.

¿Puedes usar las cuatro juntas? (sí - y deberías)

Estas primitivas se combinan; no compiten. Una configuración madura de Claude Code usa las cuatro a la vez, cada una haciendo la única cosa en la que es mejor. Aquí tienes un ejemplo concreto de principio a fin de un flujo de revisión de código:

1. Una Skill define tu procedimiento de revisión - qué revisar, en qué orden, y los estándares de tu equipo.
2. Claude delega la revisión real a un Subagent, así que el análisis archivo por archivo se ejecuta en su propio contexto y solo vuelve el veredicto.
3. Ese subagent usa un servidor MCP de GitHub para leer el pull request real - diffs, comentarios, estado de CI.
4. Un Hook bloquea el commit de forma determinista si los tests fallan, sin importar lo que concluyó el modelo.

De eso se trata: una skill, un subagent, un servidor MCP y un hook, cada uno cubriendo un hueco que los demás no pueden. Montar todo esto a mano es trabajo de verdad - escribes archivos de skill, redactas prompts de subagent, conectas servidores MCP y pruebas hooks. Si prefieres no construir cada pieza desde cero, hay kits curados que ya traen estas primitivas listas; AgentKit para Claude Code (20% de descuento por el enlace) es el que recomiendo a la gente. Más sobre eso enseguida.

Sáltate la configuración - ten las cuatro listas con AgentKit

Una aclaración rápida, porque el nombre coincide: este es AgentKit para Claude Code en agentkit.best (CLI ak) - no el AgentKit de OpenAI (Agent Builder / ChatKit). Un producto completamente distinto.

Lee mi opinión completa y honesta en la reseña de AgentKit antes de decidir, o compárala con otras opciones en AgentKit frente a las alternativas.

Preguntas frecuentes

Skill o subagent - ¿cuál para una tarea repetible?

Usa una Skill. Un procedimiento repetible (una lista de revisión, un estilo de mensaje de commit) es conocimiento que el modelo principal aplica en contexto. Recurre a un subagent solo cuando esa tarea sea lo bastante pesada como para que quieras aislarla en su propia ventana de contexto y que no te llene la conversación principal.

¿El MCP sustituye a las skills?

No. Resuelven problemas distintos. Una Skill añade instrucciones y conocimiento; el MCP añade la capacidad de alcanzar herramientas y datos externos, como una base de datos o GitHub. Si Claude solo necesita saber algo, usa una skill. Si necesita hacer algo en un sistema externo, usa el MCP. A menudo trabajan juntos.

¿Los hooks son IA o solo scripts?

Solo scripts. Un hook es un comando de shell determinista que se dispara en un evento del ciclo de vida, como PreToolUse o Stop. Se ejecuta sin importar el juicio del modelo, y por eso es justo la opción correcta para barreras como el formateo automático, la imposición de tests o el escaneo de secretos.

¿Los subagents cuestan más tokens?

Pueden. Cada subagent levanta su propio contexto y reestablece el estado, así que las tareas triviales envueltas en un subagent son puro sobrecoste. La ventaja es que mantener el trabajo pesado fuera de tu contexto principal puede ahorrar tokens en conjunto. También puedes ejecutar subagents en modelos más baratos para controlar el costo.

¿Los comandos de barra se convirtieron en skills?

Sí. Desde 2026, los comandos de barra personalizados están fusionados con las skills - un antiguo .claude/commands/x.md es el mismo concepto que un SKILL.md. Trata los comandos como una forma de invocar una skill por su nombre, no como una quinta primitiva aparte.

¿Necesito las cuatro?

No para empezar. La mayoría empieza con una o dos y añade el resto según van surgiendo las necesidades. Eso sí, una configuración completa usa las cuatro, y si las quieres listas, un kit curado como AgentKit entrega skills, subagents e integraciones MCP ya construidos, para que tú solo conectes los hooks.

Conclusión + próximos pasos

La regla general vale la pena memorizarla: para añadir conocimiento → Skill; para añadir una herramienta o fuente de datos → MCP; para aislar un trabajo pesado → Subagent; para imponer algo de forma determinista → Hook. Recuerda los dos pilares - solo los Hooks son deterministas, solo los Subagents obtienen su propia ventana de contexto - y elegirás la primitiva correcta siempre. Desde aquí, profundiza en las skills de Claude Code o, si prefieres partir de una base ya construida, hazte con el kit (20% de descuento por el enlace) y lee primero la reseña honesta de AgentKit.