Claude Code da mucho de sí tal cual viene, pero cuando te das cuenta de que escribes las mismas instrucciones todos los días, algo falla. Tiene tres piezas pensadas justo para eso: comandos personalizados, subagentes y hooks.

Se parecen y al principio se confunden, así que empiezo por lo que hace cada una y después paso a ejemplos que puedes copiar y adaptar.
Qué hace cada una
Un comando es un prompt guardado que lanzas escribiendo /nombre. Un subagente es un asistente especializado, con su propio contexto y sus propias herramientas, al que Claude le delega trabajo. Un hook es un comando de shell que se ejecuta solo en un momento concreto: antes de usar una herramienta, después de editar un archivo, cuando Claude termina.
La diferencia clave es que los comandos y los subagentes dependen del modelo, y los hooks no. Un hook se ejecuta siempre, se acuerde el modelo o no. Por eso es el sitio para todo lo que tiene que pasar sí o sí.
Comandos personalizados
Son archivos Markdown en .claude/commands/ dentro del proyecto, o en ~/.claude/commands/ si los quieres para todos tus proyectos. El nombre del archivo es el nombre del comando, y $ARGUMENTS recibe lo que escribas a continuación.
Este es .claude/commands/revisar.md:
--- description: Revisa los cambios sin confirmar antes de hacer commit --- Revisa los cambios que tengo sin confirmar usando git diff. Busca errores, casos límite sin cubrir, código duplicado y secretos que se hayan colado. No modifiques nada, solo dame una lista de problemas ordenada por gravedad. Céntrate en: $ARGUMENTS
Lo usas así:
/revisar la gestión de errores
Otro que me parece útil en un proyecto FastAPI es un comando /nuevo-endpoint que describe cómo crear un router, un servicio, un esquema y un test siguiendo las convenciones del proyecto. Lo escribes una vez y todos los endpoints salen igual.
Subagentes
Viven en .claude/agents/ o en ~/.claude/agents/. Cada uno es un archivo Markdown con una cabecera que dice quién es y un cuerpo que funciona como sus instrucciones.
--- name: revisor-codigo description: Revisa código recién modificado. Úsalo después de terminar un cambio o antes de hacer commit. tools: Read, Grep, Glob, Bash --- Eres un revisor de código estricto pero práctico. Cuando te llamen: 1. Mira los cambios recientes con git diff. 2. Revisa errores lógicos, gestión de errores, seguridad y tests que falten. 3. Devuelve una lista corta, ordenada por gravedad, con archivo y línea. No edites archivos.
Hay tres cosas que notar. La description es lo que Claude usa para decidir cuándo delegarle trabajo, así que escríbela con claridad. La línea tools limita lo que puede hacer, y este puede leer pero no editar. Y como trabaja en su propio contexto, todos los archivos que lee no llenan tu conversación principal. Eso es lo que los hace útiles para tareas que consumen mucho contexto, como explorar un código grande o revisar un cambio extenso.
Puedes escribir el archivo a mano o usar /agents, que te guía para crear uno.
Hooks
Se configuran en settings.json, ya sea en .claude/settings.json para el proyecto o en ~/.claude/settings.json para todo. También puedes usar /hooks para configurarlos desde dentro de Claude Code.
El hook recibe los detalles de lo que está pasando como JSON por la entrada estándar, así que desde ahí puedes leer qué archivo se está editando o qué comando está a punto de ejecutarse.
Formatear los archivos al editarlos
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
}
]
}
]
}
}
Cada vez que Claude edita o crea un archivo, Prettier lo formatea. Si trabajas en Python, cambia Prettier por ruff format. Si un tipo de archivo no lo soporta el formateador, mostrará un error, pero no estorba.
Bloquear la edición de archivos protegidos
Aquí se usa PreToolUse, que se ejecuta antes de que la herramienta haga nada. Crea un script en .claude/hooks/proteger.sh:
#!/bin/bash
archivo=$(jq -r '.tool_input.file_path // empty')
case "$archivo" in
*.env*|*package-lock.json)
echo "No se puede editar $archivo: es un archivo protegido." >&2
exit 2
;;
esac
exit 0
Hazlo ejecutable con chmod +x .claude/hooks/proteger.sh y regístralo:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "$CLAUDE_PROJECT_DIR/.claude/hooks/proteger.sh"
}
]
}
]
}
}
El código de salida 2 es lo que bloquea la acción, y el mensaje que imprimes por stderr le llega a Claude, así entiende por qué no pudo y puede cambiar de enfoque.
Un aviso cuando termina
Si lanzas tareas largas y te cambias de ventana, este viene bien:
{
"hooks": {
"Stop": [
{
"hooks": [
{
"type": "command",
"command": "notify-send 'Claude Code' 'Ha terminado'"
}
]
}
]
}
}
notify-send es para Linux. En macOS usarías osascript.
Además de estos hay más eventos, como UserPromptSubmit, Notification o SessionStart. Empieza por los de arriba y añade más cuando los necesites.
Un aviso: los hooks ejecutan comandos con los permisos de tu usuario y sin preguntar. Lee con cuidado cualquier hook que copies de otro sitio antes de activarlo.
Cuál usar
- Repites el mismo prompt: un comando.
- La tarea necesita un perfil especializado o llena el contexto de archivos: un subagente.
- Algo tiene que pasar siempre, sin excepciones: un hook.
Y se combinan bien. Un comando /revisar que llama al subagente revisor, un hook que formatea todo lo que toca Claude y otro que protege los archivos que no quieres que se editen. Con esas tres cosas te ahorras la mayoría de las instrucciones repetitivas.

Ingeniero en Informática, Investigador, me encanta crear cosas o arreglarlas y darles una nueva vida.