Plantillas de Claude Code: skills, agentes, hooks y más

¿Qué son las plantillas de Claude Code?

Las plantillas de Claude Code son archivos de configuración reutilizables que personalizan cómo se comporta Claude Code en un proyecto o en todo tu entorno local.

Lo importante es que las plantillas se basan en archivos. No las instalas desde una interfaz de ajustes típica ni vas haciendo clic por pantallas de configuración. En su lugar, Claude Code detecta archivos y carpetas concretos, carga los metadatos relevantes en el contexto y usa esa información para decidir cómo comportarse.

En la práctica, suelen ser archivos en Markdown, JSON o shell, guardados en carpetas a nivel de proyecto como .claude/, o empaquetados en directorios tipo plugin para compartirlos.

Una estructura típica a nivel de proyecto podría ser así:

my-app/
├── CLAUDE.md
├── .mcp.json
└── .claude/
    ├── skills/
    │   └── database-migration/
    │       └── SKILL.md
    ├── agents/
    │   └── security-auditor.md
    ├── commands/
    │   └── summarize-pr.md
    └── settings.json

Plantillas de Claude Code vs CLAUDE.md

CLAUDE.md sigue siendo importante, pero cumple otra función. Piensa en CLAUDE.md como el briefing del proyecto: qué es, qué comandos importan, qué estándares de código aplican y qué convenciones de arquitectura debe recordar Claude.

Para una guía más detallada, consulta nuestra guía para redactar CLAUDE.md.

Las plantillas son más modulares:

• Una skill puede codificar un flujo de migraciones.
• Un agente puede aislar una persona experta en revisiones de seguridad.
• Un hook puede ejecutarse tras editar archivos.
• Una configuración MCP puede conectar Claude con GitHub, SQLite u otro sistema externo.

Aquí es donde las plantillas encajan con el diseño general de flujos en Claude Code. Las plantillas potentes funcionan mejor cuando se combinan con buenos hábitos de planificación, pruebas y traspaso de contexto.

Puedes ver más prácticas de este tipo en nuestra guía de buenas prácticas.

Los comandos personalizados también están cubiertos por el sistema de skills, aunque el formato heredado .claude/commands/ sigue funcionando. El nuevo formato recomendado es .claude/skills/<name>/SKILL.md, que admite invocación con barra y activación automática por parte de Claude.

¿Qué tipos de plantillas de Claude Code puedo usar?

El ecosistema de plantillas de Claude Code suele organizarse en seis categorías: skills, agentes, comandos, hooks, integraciones MCP y plugins.

Las cinco primeras cambian directamente el comportamiento de Claude. Los plugins son algo distintos: son un formato de distribución que puede agrupar skills, agentes, hooks, comandos, servidores MCP y otros componentes en un paquete reutilizable.

A continuación veremos cada categoría.

1. Skills

Las skills son paquetes de instrucciones para tareas repetibles de varios pasos. Suele ser una carpeta que contiene un archivo SKILL.md con frontmatter en YAML y un cuerpo en Markdown.

El frontmatter describe qué hace la skill y cómo debe comportarse; el cuerpo indica a Claude qué pasos seguir. Para profundizar, consulta esta guía de Claude Skills.

Claude usa la descripción de la skill para decidir cuándo es relevante. Por defecto, tanto tú como Claude podéis invocar una skill: puedes escribir /skill-name o Claude puede cargarla automáticamente cuando la tarea actual encaje con su descripción. También puedes desactivar la invocación automática del modelo en flujos donde prefieras control manual, como despliegues.

Aquí tienes un ejemplo breve de archivo: .claude/skills/database-migration/SKILL.md

---
name: database-migration
description: Use when creating, reviewing, or modifying database migrations. Ensures migrations are reversible, tested, and checked before and after execution.
allowed-tools:
  - Read
  - Write
  - Bash
---

# Database Migration Skill

When working on a database migration:

1. Inspect the existing schema and migration history before writing changes.
2. Confirm whether the migration is additive, destructive, or data-transforming.
3. Create a reversible migration whenever the framework supports rollback.
4. Run the project’s migration check command before applying the migration.
5. Run tests that cover the affected models, queries, or API endpoints.
6. After writing the migration, summarize:
   - schema changes
   - rollback behavior
   - affected tables
   - test commands run

Esto es útil porque las instrucciones son procedimentales. No le dices a Claude solo que «tenga cuidado con las migraciones», le das una checklist repetible.

Las skills son ideales para cualquier cosa que de otro modo pegarías en Claude más de dos veces: generar endpoints de API, redactar changelogs, crear andamiajes de tests, preparar notas de versión, revisar pull requests o realizar comprobaciones de migraciones.

Para inspirarte sobre lo que están convirtiendo en flujos de IA reutilizables los desarrolladores, echa un vistazo a nuestra lista de Agent Skills.

2. Agentes

Los agentes, más concretamente subagentes personalizados en Claude Code, son asistentes de IA especializados con su propia definición en Markdown, frontmatter en YAML, restricciones de herramientas, elección de modelo y prompt del sistema.

Pueden vivir en .claude/agents/ con alcance de proyecto o en ~/.claude/agents/ con alcance personal. Se crean pidiéndoselo a Claude o editando directamente archivos Markdown en la carpeta .claude/agents/.

Hay una diferencia clara entre skills y agentes. Una skill define cómo realizar una tarea. Un agente define quién debe ser Claude al trabajar: su rol, foco, permisos y límites.

Veamos este ejemplo de agente:

---
name: security-auditor
description: Reviews code for security vulnerabilities and produces a findings report without modifying files.
tools: Read, Glob, Grep, Bash
model: sonnet
---

You are a security auditor.

Your task is to inspect the codebase for vulnerabilities, risky patterns, and missing safeguards.

Rules:
- Do not edit files.
- Do not suggest broad rewrites unless directly tied to a security issue.
- Focus on authentication, authorization, input validation, secrets, dependency risk, and unsafe shell or SQL usage.
- Produce a findings report with severity, affected files, evidence, and recommended next steps.

Este agente es útil porque marca límites claros para Claude. En una sesión general, Claude podría lanzarse a corregir problemas en cuanto los detecta. Un agente auditor de seguridad está instruido para inspeccionar y reportar, evitando modificaciones.

Los agentes son mejores para dominios especializados como auditoría de seguridad, revisión de documentación, revisión de arquitectura, ingeniería de datos o controles de calidad de código, donde importa aislar el contexto y acotar permisos.

También brillan cuando se combinan con skills especializadas. Por ejemplo, un agente auditor de seguridad puede invocar una skill de informe de hallazgos, mientras que un agente revisor de frontend puede usar una skill de tests de componentes.

3. Comandos

Los comandos son atajos invocados con barra, como /generate-tests, /check-deps o /summarize-pr. Históricamente, los comandos personalizados se guardaban como archivos Markdown en .claude/commands/, usando el nombre del archivo como nombre del comando.

Claude Code sigue admitiendo este formato heredado, pero te recomiendo usar skills para nuevos flujos tipo comando, ya que admiten la misma invocación /name y la activación automática cuando proceda.

Los comandos son ideales cuando quieres que el disparador sea explícito. Una skill puede activarse automáticamente si Claude detecta una tarea coincidente, pero un comando solo debe ejecutarse cuando tú lo decidas. Por eso funcionan bien como puntos de control: «genera tests ahora», «resume este PR ahora», «revisa dependencias ahora» o «prepara el mensaje de commit ahora».

4. Hooks

Los hooks son reglas de automatización que se ejecutan en respuesta a eventos del ciclo de vida de Claude Code. Son comandos de shell definidos por el usuario que se ejecutan en momentos concretos del ciclo de vida de Claude Code, dando control determinista sobre el comportamiento.

La diferencia con las plantillas vistas hasta ahora es que no se activan por lo que pides, sino por lo que hace Claude.

Dicho simple: no necesitas confiar en que Claude recuerde formatear un archivo tras editarlo; un hook puede hacerlo automáticamente.

Los nombres de eventos actuales incluyen PreToolUse, PostToolUse, Notification y Stop.

Ejemplo: ejecutar un formateador después de que Claude edite o escriba un archivo:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

Example: block risky shell commands before Claude runs them:
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "python3 .claude/hooks/block-dangerous-bash.py"
          }
        ]
      }
    ]
  }
}

Los hooks son ideales para reglas que Claude no debería poder saltarse: ejecutar un linter, formatear archivos editados, bloquear ediciones de archivos protegidos, comprobar el código generado o enviar avisos cuando Claude necesita información.

Para un tutorial en profundidad, lee nuestra guía de hooks de Claude Code.

5. Integraciones MCP

Las integraciones MCP conectan Claude Code con herramientas, fuentes de datos y APIs externas mediante Model Context Protocol. MCP actúa como una capa conectora entre sistemas de IA y herramientas externas. En Claude Code, esto significa que Claude puede ir más allá de los archivos locales y los comandos de shell.

Le permite interactuar con servicios externos como GitHub, bases de datos, sistemas de documentación, plataformas cloud o APIs internas, según qué servidores MCP configures. Para una explicación completa y un proyecto de demostración, consulta nuestro tutorial del Model Context Protocol.

Un servidor MCP puede exponer tres tipos amplios de capacidades:

• Tools: funciones ejecutables que Claude puede llamar, como crear una incidencia en GitHub o ejecutar una consulta en base de datos.
• Resources: fuentes de contexto de solo lectura, como un archivo, una fila de base de datos o un documento.
• Prompts: plantillas de tareas reutilizables expuestas por el servidor.

Un .mcp.json a nivel de proyecto puede configurar varios servidores en paralelo:

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "sqlite": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "./data/app.db"
      ]
    }
  }
}

Esto importa porque Claude solo puede razonar con el contexto y las herramientas a las que tiene acceso. Sin MCP, puede inspeccionar archivos locales, pero no tu gestor de incidencias, tu base de datos, tu entorno cloud o tu API interna.

MCP es la mejor opción cuando Claude necesita trabajar con tu stack real y acceder a datos externos, no solo con una instantánea estática del código.

6. Plugins

Los plugins son paquetes. Pueden incluir skills, agentes, hooks, configuraciones MCP, comandos y otros componentes dentro de una única estructura instalable.

En Claude Code, un plugin suele incluir un manifiesto .claude-plugin/plugin.json y carpetas de componentes como skills/, agents/, hooks/ y .mcp.json en la raíz del plugin.

Ejemplo de estructura de plugin:

frontend-workflow-plugin/
├── .claude-plugin/
│   └── plugin.json
├── skills/
│   └── component-test/
│       └── SKILL.md
├── agents/
│   └── frontend-reviewer.md
├── hooks/
│   └── hooks.json
└── .mcp.json

Ejemplo de plugin json:

{
  "name": "frontend-workflow",
  "displayName": "Frontend Workflow",
  "version": "1.0.0",
  "description": "Frontend development workflow with review agents, test skills, and formatting hooks",
  "author": {
    "name": "Your Team"
  }
}

Los plugins no añaden un tipo de comportamiento nuevo: hacen que los demás sean portables. Úsalos cuando quieras compartir una configuración completa con tu equipo, reutilizar el mismo flujo entre proyectos o instalar un paquete mantenido por la comunidad en lugar de crear cada archivo a mano.

Para construir uno desde cero, consulta la guía paso a paso de plugins de Claude Code de DataCamp.

¿Qué tipo de plantilla debo elegir?

Es normal que estos tipos confundan: todos pueden cambiar cómo se comporta Claude. La diferencia está sobre todo en cómo se disparan y el tipo de control que ofrecen.

Para aclararlo, aquí tienes una comparación:

Una regla sencilla para decidir:

• Si quieres hacer cumplir una regla automáticamente cada vez que Claude toque código, usa un hook.
• Si quieres que Claude adopte una gran especialización para una tarea concreta, usa un agente.
• Si quieres codificar un flujo de trabajo que Claude deba repetir de forma consistente, usa una skill.
• Si quieres invocar tú mismo una acción en el momento justo, usa un comando o una skill tipo comando.
• Si Claude necesita servicios externos o datos en vivo, usa MCP.
• Si quieres instalar o compartir una configuración completa de flujo de trabajo, usa un plugin.

En proyectos reales, estos tipos suelen combinarse. Un plugin de seguridad puede agrupar un agente security-auditor, una skill audit-findings, un comando de comprobación de dependencias y un hook pre-commit. El agente define el rol, la skill define la estructura del informe, el comando te da un punto de control explícito y el hook impone la barandilla.

Para flujos donde Claude deba seguir un plan formal antes de la implementación, el desarrollo guiado por especificaciones suele ser mejor que los prompts improvisados.

¿Dónde puedo encontrar plantillas de Claude Code?

Hay tres fuentes prácticas: Anthropic, colecciones de la comunidad y tú mismo.

Primero, empieza por los recursos oficiales de Anthropic y su documentación. La documentación de Claude Code de Anthropic cubre skills, subagentes, hooks, MCP y plugins, y es el mejor lugar para verificar formatos de archivo y comportamientos actuales antes de publicar nada para producción.

Segundo, usa colecciones de la comunidad. El hub comunitario más visible es aitmpl.com, que se define como un catálogo de configuraciones listas para usar en proyectos de Claude Code. Su navegación actual incluye Skills, Agents, Commands, Settings, Hooks, MCPs y Plugins.

El comando de instalación interactiva actual es:

npx claude-code-templates@latest

La documentación del proyecto también muestra un alias más corto:

npx cct@latest

Para componentes concretos, el README en GitHub muestra comandos de instalación como:

npx claude-code-templates@latest --agent development-tools/code-reviewer --yes
npx claude-code-templates@latest --command performance/optimize-bundle --yes
npx claude-code-templates@latest --hook git/pre-commit-validation --yes
npx claude-code-templates@latest --mcp database/postgresql-integration --yes

También muestra instalaciones en lote de una pila completa usando varias flags en un solo comando.

Al evaluar plantillas de la comunidad, comprueba estas señales de calidad:

• ¿La description es lo bastante específica como para que Claude dispare la skill o el agente correctamente?

• ¿Los allowed-tools están bien acotados o la plantilla pide permisos amplios de escritura y bash sin necesidad?

• ¿Se ha mantenido el repositorio recientemente?

• ¿La plantilla explica qué cambia?

• ¿Incluye hooks o servidores MCP que ejecuten código que no hayas revisado?

Tercero, escribe las tuyas. Suele ser lo ideal para flujos muy ligados a tu stack. Una plantilla comunitaria puede darte una base útil, pero no conoce tu política interna de migraciones, tus convenciones de nombres, tu modelo de datos o tu tolerancia al riesgo en despliegues.

Reflexiones finales

Las plantillas de Claude Code son la forma de pasar de un asistente sesión a sesión a un entorno de desarrollo persistente.

Las seis categorías que hemos visto son capas: las skills codifican flujos, los agentes definen roles, los comandos crean acciones explícitas, los hooks imponen barandillas, MCP conecta sistemas externos y los plugins empaquetan todo para su reutilización.

El mejor punto de partida no es un gran stack de plugins. Empieza con una skill para tu flujo más repetido. Cuando veas dónde el comportamiento por defecto de Claude aún genera fricción, añade un agente para revisiones especializadas, un hook para hacer cumplir reglas o un servidor MCP para acceder a sistemas en vivo.

Para seguir aprendiendo sobre Claude Code, echa un vistazo a nuestros cursos Claude Code 101 y Claude Code in Action.