Claude Code Hooks: guía práctica de automatización del flujo de trabajo

Cuando trabajas con Claude Code, aparece un problema recurrente: escribe buen código, pero se olvida de pasos clave como formatear, ejecutar tests o seguir protocolos de seguridad. Terminas repitiendo los mismos recordatorios una y otra vez. Los hooks de Claude Code te permiten automatizar esos recordatorios ejecutando comandos de shell automáticamente en puntos concretos de tu flujo de trabajo.

En este tutorial, verás cómo configurar hooks para formateo de código, ejecución de tests, notificaciones y protección de archivos. Construirás un sistema de automatización que haga cumplir tus estándares de desarrollo sin intervención manual.

Si quieres saber más sobre Claude Code, echa un vistazo a nuestra guía de buenas prácticas de Claude Code y a nuestro tutorial de Claude Skills. Si te interesa aprender a configurar instrucciones a nivel de proyecto, consulta nuestra guía para escribir un CLAUDE.md.

Resumen

• Los hooks de Claude Code son comandos de shell que se ejecutan automáticamente en momentos concretos del ciclo de vida de Claude Code (antes/después de usar herramientas, al iniciar sesión, cuando Claude se detiene)

• Configúralos en .claude/settings.json (proyecto) o ~/.claude/settings.json (global) usando JSON con eventos, matchers y comandos

• Usa hooks PreToolUse para bloquear operaciones peligrosas antes de que ocurran (código de salida 2 = bloquear)

• Usa hooks PostToolUse para tareas de limpieza como formateo, linting o ejecución de tests después de que Claude escriba código

• Los hooks reciben contexto en JSON por stdin y comunican resultados mediante códigos de salida, stdout y stderr

¿Qué son los hooks de Claude Code?

Los hooks de Claude Code son comandos de shell que se ejecutan automáticamente cuando suceden eventos concretos durante tu sesión de programación con IA. Piénsalos como disparadores automáticos que ejecutan tus scripts en el momento exacto—antes de que Claude escriba un archivo, después de ejecutar un comando o cuando te envía una notificación.

El sistema funciona monitorizando las acciones de Claude Code y comparándolas con reglas que defines en un archivo de configuración. Cuando hay coincidencia, se ejecuta el comando que hayas indicado con acceso al contexto de lo que acaba de pasar. Así controlas el comportamiento de Claude y automatizas tareas repetitivas que, de otro modo, requerirían intervención manual.

Este es un hook básico que ejecuta un formateador de código cada vez que Claude escribe un archivo de Python:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}Con la tecnología de

Este hook tiene tres partes: 

• El evento: PostToolUse (tras finalizar una acción de Claude)

• El matcher: Write (solo al escribir archivos)

• El comando: python -m black . (formatea los archivos de Python del directorio actual)

El hook recibe información detallada sobre lo que acaba de hacer Claude a través de datos JSON enviados a la entrada del script, así que puedes crear automatizaciones más sofisticadas que reaccionen a cambios específicos de archivos.

Si quieres ir más allá con la automatización en Claude Code, nuestro tutorial de Claude Code Routines muestra cómo programar hooks y agentes para que se ejecuten de forma recurrente en la nube.

Veamos cómo crear hooks desde cero y registrarlos en Claude Code.

Requisitos previos

Antes de empezar, necesitas tener a punto unas cuantas cosas:

• Claude Code instalado y en marcha: Deberías sentirte cómodo usando Claude Code para tareas de programación básicas

• Familiaridad con la línea de comandos: Los hooks ejecutan comandos de shell, así que necesitas saber escribir comandos de terminal básicos en tu sistema operativo

• Acceso a un editor de texto: Editarás archivos de configuración JSON para configurar tus hooks

• Directorio de proyecto: Un proyecto donde puedas probar hooks con seguridad sin afectar trabajo importante

No hace falta ser experto en scripting de shell, pero entender cómo ejecutar comandos como ls, cd y operaciones básicas con archivos te ayudará a seguir los ejemplos. Si eres nuevo en bash o en la terminal, te recomendamos nuestro curso Introduction to Shell.

Primeros pasos con los hooks de Claude Code

Ahora que sabes qué son los hooks, vamos a configurar tu primera automatización. El proceso consiste en elegir el evento adecuado, configurar una regla sencilla y probarla con un comando básico.

Entender los eventos de los hooks

Claude Code expone más de 25 eventos de hook. La tabla siguiente cubre los 10 que usarás con más frecuencia. Para la lista completa, consulta la referencia oficial de hooks.

PreToolUse y PostToolUse son los eventos más comunes. PreToolUse se ejecuta antes de que Claude realice una acción como escribir un archivo o ejecutar un comando, por lo que es perfecto para validaciones o para bloquear operaciones peligrosas. PostToolUse se ejecuta después de completar una acción, ideal para tareas de limpieza como formatear código o ejecutar tests.

UserPromptSubmit se dispara cuando envías un prompt a Claude, antes de que procese tu solicitud. Puedes usarlo para añadir contexto a la conversación o validar que los prompts cumplan ciertos requisitos.

Notification se ejecuta cuando Claude te envía avisos, como pedir permiso para ejecutar un comando o cuando necesita tu input. PermissionRequest se dispara cuando Claude Code muestra un diálogo de permisos, lo que te permite aprobar o denegar automáticamente la solicitud en nombre del usuario.

Stop y SubagentStop se disparan cuando Claude termina de responder, lo que resulta útil para comprobaciones finales o generar informes. La diferencia es que Stop salta cuando Claude termina su respuesta general, mientras que SubagentStop lo hace cuando un asistente lanzado por una herramienta (un “subagent”) finaliza su trabajo.

Los eventos restantes, PreCompact, SessionStart y SessionEnd, cubren situaciones del ciclo de vida. PreCompact se ejecuta justo antes de que Claude compacte el historial. SessionStart salta al inicio de una nueva sesión para establecer valores por defecto, y SessionEnd se dispara cuando la sesión se cierra, permitiendo limpieza o informe final.

Entender los matchers

Los matchers son filtros que deciden qué acciones de Claude Code disparan un hook. Técnicamente son cadenas interpretadas como expresiones regulares, así que puedes usar coincidencias exactas o patrones más flexibles. 

Los matchers más relevantes son sencillos como Write (salta cuando Claude escribe un archivo) o Edit (cuando edita contenido), y combinaciones como Edit|Write para cubrir varias acciones. 

También puedes usar prefijos como Notebook.* para coincidir con todas las herramientas que empiezan por “Notebook”. Si quieres que el hook salte en cualquier acción, usa la regex universal .*, una cadena vacía ("") o deja matcher en blanco.

Como los matchers distinguen mayúsculas/minúsculas y actúan solo sobre nombres de acción, es mejor mantenerlos lo más específicos posible. Cuando necesites mayor control (por ejemplo, limitar el hook a ciertos tipos de archivo) puedes leer el payload JSON que Claude pasa al hook y aplicar ahí tus propias regex o condiciones.

Crear tu primer hook en Claude Code

Claude Code ofrece dos formas de configurar hooks: mediante el comando interactivo /hooks o editando directamente los archivos de configuración. Empecemos con el enfoque interactivo porque es más amigable para empezar.

Usando el comando /hooks:

1. Abre Claude Code y escribe /hooks en la interfaz de chat

2. Elige el evento disparador (selecciona PostToolUse en este ejemplo)

3. Selecciona "Add new hook" en el menú

4. Define tu patrón de matcher (introduce Write para apuntar a escrituras de archivos)

5. Introduce tu comando:

• Mac: say "Task complete"

• Windows: powershell -c [console]::beep()

• Linux: spd-say "Task complete"

6. Guarda la configuración y vuelve a Claude Code pulsando Esc tres veces

El comando /hooks actualizará tu archivo de ajustes y recargará la configuración automáticamente. También puedes usar /hooks en cualquier momento para ver tus hooks existentes o hacer cambios.

Si prefieres editar los archivos de configuración directamente, los hooks viven en ~/.claude/settings.json para ajustes globales, en .claude/settings.json dentro del directorio del proyecto (súbelo al repo para compartirlo con el equipo), o en .claude/settings.local.json para hooks personales que Git ignora por defecto. Para nuestro ejemplo anterior, quedaría así:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}Con la tecnología de

Tras editar el archivo manualmente, reinicia Claude Code o usa el comando /hooks para recargar la configuración. Ahora, cada vez que Claude escriba un archivo, oirás una notificación de audio.

Probar tu hook

Antes de continuar, verifica que tu hook funciona de verdad:

1. Pídele a Claude que escriba cualquier archivo de Python (p. ej., "Crea un archivo hello.py que imprima hello world")

2. Deberías oír la notificación de audio cuando Claude complete la escritura

3. Si no oyes nada, revisa la transcripción de Claude Code con Ctrl-O para ver mensajes de error

4. Los problemas más comunes son: no se encuentra el comando del hook, permisos de archivo incorrectos o errores de sintaxis en el archivo de configuración

Lograr que esta prueba básica funcione te ahorrará tiempo de depuración cuando construyas hooks más complejos. Si acabas de editar a mano el archivo de ajustes, has cambiado el matcher o el evento, o has instalado nuevas herramientas que usarás en un comando del hook, puede ayudar reabrir /hooks o reiniciar Claude para recargar la configuración.

Este patrón básico (evento, matcher, comando) es la base de toda la automatización con hooks. Puedes ampliarlo añadiendo varios comandos para ejecutarlos a la vez cuando se dispare el mismo evento. Por ejemplo, quizá quieras reproducir un sonido y crear una copia de seguridad cuando Claude escriba un archivo. 

También puedes crear matchers separados para distintas herramientas dentro del mismo evento, de forma que la escritura de archivos dispare acciones diferentes que la edición de código. Todos los hooks que coincidan con el mismo patrón de herramienta se ejecutan en paralelo. Si configuras varios matchers para el mismo evento, cada hook se ejecuta cuando se dispara su matcher.

Trabajar con la entrada de los hooks

Cuando Claude Code dispara un hook, envía información sobre lo que acaba de ocurrir a través de la entrada estándar (stdin), un flujo de datos que llega directamente a tu comando cuando se ejecuta. Estos datos son lo que hacen a los hooks potentes, y no meros scripts que corren al azar. 

Claude Code empaqueta esta información como JSON y se la pasa al comando que hayas configurado, ya sea un comando simple de terminal o un script propio.

Anatomía de la entrada de un hook

Cada hook recibe un objeto JSON con campos básicos sobre la sesión actual:

{
  "session_id": "abc123",
  "transcript_path": "/Users/you/.claude/projects/my-project/conversation.jsonl", 
  "cwd": "/Users/you/my-project",
  "hook_event_name": "PostToolUse"
}Con la tecnología de

Traduzcamos cada componente:

• session_id: identifica tu conversación actual

• transcript_path: ruta del historial de la conversación

• cwd: directorio de trabajo

• hook_event_name: indica qué evento se disparó

Con este contexto, tus hooks pueden tomar decisiones inteligentes: saber qué conversación disparó una acción, acceder al historial completo si hace falta o ejecutar comandos en el directorio correcto.

Variaciones de entrada según el evento

Los eventos de herramientas como PreToolUse y PostToolUse incluyen detalles extra sobre la acción, y aquí es donde los hooks se vuelven realmente útiles para automatizar. En PreToolUse se especifica tool_input y, además, en PostToolUse aparece tool_response:

{
  "session_id": "abc123",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "print('Hello world')"
  },
  "tool_response": {
    "filePath": "/path/to/file.py", 
    "success": true
  }
}Con la tecnología de

En la entrada del hook, file_path muestra la ruta del archivo que se va a escribir o editar, mientras que content contiene el texto exacto que la herramienta está a punto de escribir. Tras la ejecución, la respuesta de la herramienta repite la filePath final (observa el camelCase) para confirmar el archivo realmente modificado, junto con un indicador success que señala si la operación se completó correctamente. 

Con esta información, tus hooks pueden responder de forma diferente según lo que haya ocurrido. Podrías formatear solo archivos de Python, hacer copias de seguridad solo de directorios importantes o enviar notificaciones solo cuando se modifiquen ciertos tipos de archivo.

Eventos como UserPromptSubmit son más sencillos porque no implican herramientas:

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}Con la tecnología de

Ten en cuenta que los hooks UserPromptSubmit no usan matchers en su configuración. Se disparan con todos los prompts, no con operaciones de herramientas. Por eso son perfectos para registrar conversaciones, añadir contexto de proyecto automáticamente o validar prompts antes de que Claude los procese.

Leer la entrada del hook en la práctica

Vamos a crear un hook que registre cada prompt del usuario. Esto evita perder de vista lo que le pediste a Claude, especialmente en sesiones largas. Primero, la configuración del hook:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}Con la tecnología de

Después, crea el script de Python en ~/.claude/log_prompts.py con el siguiente contenido:

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

# Read JSON data from stdin
input_data = json.load(sys.stdin)

# Extract information
session_id = input_data.get("session_id", "unknown")
prompt = input_data.get("prompt", "")
timestamp = datetime.now().isoformat()

# Log the prompt
log_entry = f"{timestamp} | Session: {session_id[:8]} | {prompt}\n"
with open("prompt_history.txt", "a") as f:
    f.write(log_entry)Con la tecnología de

El script lee los datos JSON que envía Claude Code y registra el prompt con el contexto de sesión. Así creas un historial consultable de tus interacciones, muy útil cuando semanas después necesitas recordar cómo resolviste un problema.

Trabajar con la salida de los hooks

Después de ejecutarse, tu comando debe indicar a Claude Code qué ha pasado y si debe continuar con normalidad. Este mecanismo de control convierte los hooks en una potente automatización del flujo de trabajo que puede guiar el comportamiento de Claude. Ocurre a través de tres canales: salida estándar (stdout), error estándar (stderr) y códigos de salida.

Canales de salida y códigos de salida

La salida estándar (stdout) representa la salida normal. Por ejemplo, si imprimes algo, va a stdout. En la mayoría de hooks, esto aparece en la transcripción de Claude Code cuando pulsas Ctrl-O, y te deja un registro de lo que hizo tu automatización sin saturar la conversación principal.

El error estándar (stderr) se refiere a mensajes de error. Puedes escribir a stderr usando 

• Python: print("message", file=sys.stderr) o

• Línea de comandos: echo "message" >&2

La diferencia clave es que stderr puede enviarse directamente a Claude para su procesamiento automático, permitiéndole responder a problemas que detecten tus hooks.

Los códigos de salida le dicen a Claude Code qué hacer a continuación:

• Código de salida 0: Éxito (muestra stdout al usuario)

• Código de salida 2: Error bloqueante (envía stderr a Claude)

• Otros códigos: Error no bloqueante (muestra stderr al usuario, pero continúa)

Este sistema te da control fino sobre cuándo Claude debe parar, continuar o recibir feedback de lo que descubrió tu automatización. Veamos ejemplos de los dos códigos más importantes.

Código de salida 0: operación normal

La mayoría de hooks usan el código 0 para indicar que todo fue bien. Este es un hook completo que registra operaciones de archivo y notifica al usuario:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import datetime; open('activity.log','a').write('File written: ' + datetime.datetime.now().isoformat() + '\\n'); print('Logged file operation')\""
          }
        ]
      }
    ]
  }
}Con la tecnología de

Este hook ejecuta dos acciones: registrar en un archivo y luego imprimir un mensaje en la transcripción. Hay muchas formas de hacerlo, pero este enfoque es multiplataforma y evita depender de particularidades de la línea de comandos.

Como no hay un código de salida explícito, por defecto es 0. El mensaje impreso aparece en la transcripción de Claude Code, dándote feedback de que el registro funcionó. Este patrón es perfecto para crear trazas de auditoría o seguir los cambios que Claude va haciendo en tu proyecto.

Código de salida 2: bloqueo con feedback

El código de salida 2 envía tu mensaje de error directamente a Claude, permitiéndole responder automáticamente. Aquí es donde los hooks se convierten en un mecanismo de seguridad y no solo en automatización. Este hook bloquea operaciones peligrosas sobre archivos:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}Con la tecnología de

Tendrás que crear el script de seguridad en ~/.claude/security_check.py:

#!/usr/bin/env python3
import json
import sys

# Read hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Check for dangerous patterns
dangerous_paths = ["/etc/", "/usr/", "production.conf"]
is_dangerous = any(pattern in file_path for pattern in dangerous_paths)

if is_dangerous:
    # Block the operation and tell Claude why
    print(f"Blocked modification of {file_path} - this appears to be a system or production file", file=sys.stderr)
    sys.exit(2)  # Sends stderr message to Claude
else:
    # Allow the operation
    print(f"Approved modification of {file_path}")
    sys.exit(0)  # Shows stdout in transcriptCon la tecnología de

Cuando este hook detecta una ruta peligrosa, sale con código 2. Claude Code envía el mensaje de stderr a Claude, que puede explicarte por qué se bloqueó la operación y sugerir alternativas. Así evitas dañar archivos del sistema y mantienes a Claude informado de tus políticas de seguridad.

Crear un hook de notificaciones inteligente para Claude Code

Vamos a crear un hook de notificaciones mejorado que combine procesamiento de entrada con un manejo inteligente de la salida. Resuelve el problema de ruido de nuestro hook original, que alertaba en cada cambio de archivo:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}Con la tecnología de

Crea el script de notificaciones en ~/.claude/smart_notify.py:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess

# Read the hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Categorize file importance
important_extensions = [".py", ".js", ".ts", ".java", ".cpp"]
config_files = ["Dockerfile", "requirements.txt", "package.json"]

is_code = any(file_path.endswith(ext) for ext in important_extensions)
is_config = any(filename in file_path for filename in config_files)

if is_code:
    # Important: notify and log
    print(f"Code file modified: {os.path.basename(file_path)}")
    subprocess.run(["say", "Code updated"], check=False)  # Mac
    sys.exit(0)  # Show message in transcript
elif is_config:
    # Very important: louder notification
    print(f"Configuration file changed: {os.path.basename(file_path)}")
    subprocess.run(["say", "Configuration updated - review changes"], check=False)
    sys.exit(0)
else:
    # Not important: silent success
    sys.exit(0)Con la tecnología de

Este hook lee la entrada para entender qué archivo se modificó, decide la importancia de la notificación según el tipo de archivo, usa stdout para registrar cambios importantes en la transcripción, dispara avisos de audio distintos según el tipo y siempre sale con código 0, ya que son acciones informativas, no bloqueantes.

La combinación de análisis de entrada y control de salida crea un hook que se comporta de forma inteligente según el contexto y ofrece el nivel adecuado de feedback tanto para ti como para Claude Code. En lugar de recibir avisos molestos por cada archivo temporal, solo oirás cambios que realmente importan a tu proyecto.

Ten en cuenta que este ejemplo usa el comando say, disponible en macOS. En Linux puedes usar notify-send, y en Windows, un comando de PowerShell, para lograr notificaciones similares.

Errores comunes con los hooks de Claude Code

Algunas cosas que suelen atrapar a casi todo el mundo durante la primera semana con hooks:

Los echos del perfil de shell rompen los hooks. Los hooks se ejecutan en shells no interactivos que cargan tu ~/.zshrc o ~/.bashrc. Si tu perfil tiene echo incondicionales, antepondrán texto al stdout del hook y romperán el parseo de JSON. Envuélvelos en una comprobación de shell interactivo:

if [[ $- == *i* ]]; then
  echo "Welcome back"
fiCon la tecnología de

Los hooks Stop pueden entrar en bucle infinito. Un hook Stop que sale con código 2 obliga a Claude a seguir trabajando. Si tu script no comprueba stop_hook_active del JSON de entrada y no sale limpiamente cuando es true, se repetirá hasta el timeout. Incluye siempre una condición de salida temprana.

Los matchers distinguen mayúsculas/minúsculas. bash no coincide con Bash. Usa el nombre exacto de la herramienta tal como aparece en Claude Code.

La salida se limita a 10.000 caracteres. Si tu hook genera más, se trunca antes de inyectarse en el contexto de Claude. Mantén stdout conciso y muestra solo lo que el modelo necesita.

Confusión entre hooks de equipo y personales. Los hooks en .claude/settings.json se comparten con el equipo (súbelos al repo). Para hooks personales que no quieras compartir, usa .claude/settings.local.json, que Git ignora por defecto.

Hooks vs. skills: cuándo usar cada uno

Los hooks y las Claude Skills tienen propósitos distintos y funcionan mejor juntos. Una skill es un archivo markdown que enseña a Claude a hacer algo (procedimientos, convenciones, plantillas). Un hook es un comando de shell que hace cumplir una regla de forma determinista, independientemente de lo que decida Claude.

La distinción importa: una skill es una sugerencia que el modelo puede ignorar bajo presión; un hook se dispara siempre. Escribe una skill para documentar el procedimiento de migración de tu equipo. Escribe un hook PostToolUse para ejecutar el linter de migración en cada archivo .sql que escriba Claude. La skill hace competente a Claude; el hook hace que rinda cuentas.

Patrones avanzados para los hooks de Claude Code

Más allá de notificaciones y registros básicos, los hooks pueden resolver problemas reales del flujo de trabajo de desarrollo que los equipos afrontan a diario. Aquí tienes algunas ideas que puedes adaptar a tus proyectos.

Lo mejor es que no tienes por qué construir estos hooks manualmente. Basta con que le des a Claude Code una de las ideas de prompt de abajo, junto con la referencia de Hooks de su documentación, y generará el código y el JSON de configuración correspondientes.

Cada uno de estos patrones se puede personalizar para tus herramientas y tu flujo. Empieza por los que resuelvan tus mayores frustraciones diarias y amplía tu automatización a medida que te familiarices con el desarrollo de hooks.

Hooks avanzados para seguridad y cumplimiento

Los hooks son excelentes para hacer cumplir reglas de seguridad y estándares de cumplimiento. Aquí tienes cuatro casos de uso.

Escáner de claves API

• Problema: Subir secretos por accidente al control de versiones

• Disparadores: Antes de escribir cualquier archivo

• Solución: Escanear contenido en busca de claves API, tokens y contraseñas con regex

“Crea un script en Python que lea el JSON de entrada del hook, extraiga el contenido del archivo y use regex para detectar formatos comunes de secretos como api_key=, token: o password=.  Para cualquier coincidencia sospechosa, haz verificación local y nunca envíes secretos sin procesar al exterior. 

Solo envía fragmentos enmascarados (p. ej., conserva 4 caracteres de prefijo/sufijo) o hashes a la API de Anthropic para analizar cadenas sospechosas y determinar si son secretos reales o nombres de variables. Sal con código 2 y proporciona a Claude feedback sobre los secretos detectados y alternativas más seguras.”

Verificador de cabecera de licencia

• Problema: Proyectos open source sin cabeceras de licencia obligatorias en archivos nuevos

• Disparadores: Antes de escribir archivos de código fuente

• Solución: Validar que los archivos nuevos .py, .js, .java contengan el texto de licencia correcto

“Analiza la entrada del hook para obtener el contenido del archivo y comprueba si las 10 primeras líneas contienen el texto de licencia mediante coincidencia de cadenas. Para validaciones más sofisticadas, envía la cabecera del archivo a Claude mediante la API de Anthropic para verificar que incluye avisos de copyright e información de licencia. Bloquea la creación del archivo con código 2 si faltan cabeceras y proporciona a Claude la plantilla de licencia correcta para añadir.”

Guardia de archivos de producción

• Problema: Modificar por accidente archivos críticos de configuración del sistema

• Disparadores: Antes de editar archivos en directorios sensibles

• Solución: Bloquear cambios en /etc/, nginx.conf, database.yml y otras configuraciones críticas

“Extrae la ruta del archivo del JSON de entrada del hook y comprueba si coincide con patrones como /etc/, production.yml u otros nombres críticos. Usa la API de Claude para analizar la ruta y determinar si es un archivo de configuración que podría afectar a sistemas de producción. Sal con código 2 y ofrece recomendaciones específicas sobre prácticas de desarrollo más seguras cuando se detecten rutas peligrosas.”

Optimizador de imágenes

• Problema: Archivos de imagen grandes que ralentizan aplicaciones y repositorios

• Disparadores: Después de añadir archivos de imagen nuevos

• Solución: Comprimir archivos PNG/JPEG manteniendo la calidad visual

“Analiza la entrada del hook para obtener la ruta del archivo y comprueba si es una imagen por su extensión. Ejecuta herramientas de compresión como imageoptim o llama a la API de TinyPNG para comprimir la imagen preservando la calidad. Registra los resultados de compresión en stdout para ver el ahorro de tamaño en la transcripción de Claude.”

Hooks avanzados para automatización con control de versiones

Los flujos con Git y la documentación son áreas donde los hooks también resultan muy útiles. Veamos algunas ideas.

Validador de ramas de Git

• Problema: Miembros del equipo que hacen push por accidente a ramas protegidas

• Disparadores: Antes de cualquier operación de escritura o edición de archivos

• Solución: Comprobar la rama actual de Git y bloquear operaciones en main/master/production

“Usa un comando bash sencillo git branch --show-current para obtener el nombre de la rama actual y compáralo con una lista de ramas protegidas. Si estás en una protegida, sal con código 2 y envía a Claude un mensaje explicando las políticas de protección. Para reglas complejas de nombres de ramas, usa la API de Claude para analizarlos y determinar si encajan con los patrones de protección.”

Auto-commit inteligente

• Problema: Olvidar hacer commit o escribir mensajes de commit pobres

• Disparadores: Después de cualquier modificación de archivos

• Solución: Preparar y hacer commit automáticamente con mensajes descriptivos generados por IA

“Lee las rutas de archivos modificados de la entrada del hook, ejecuta git diff para obtener los cambios y envía el diff a la API de Claude con un prompt pidiendo un mensaje de commit conciso. Usa el mensaje generado con git add y git commit para confirmar los cambios automáticamente. Incluye nombres de archivo y tipos de cambio en el prompt a la API para que los mensajes sigan el estándar de conventional commits.”

Generador de documentación

• Problema: La documentación de API se desincroniza con los cambios de código

• Disparadores: Tras modificar archivos de interfaz (controladores, modelos, APIs)

• Solución: Ejecutar automáticamente herramientas de documentación como JSDoc, Sphinx u OpenAPI generators

“Comprueba la ruta del archivo modificado para determinar si es un endpoint de API, un modelo o un archivo de interfaz usando patrones. Envía el contenido del archivo a la API de Claude pidiéndole que extraiga cambios de la API y genere actualizaciones de documentación. Ejecuta la herramienta correspondiente (jsdoc, sphinx-build, etc.) y haz commit de la documentación actualizada automáticamente.

Hooks avanzados para colaboración e integración de flujo

Por último, los hooks ayudan a mantener al día a todo el equipo.

Integración con Slack

• Problema: El equipo no se entera de cambios importantes en bases de código compartidas

• Disparadores: Cuando se envían notificaciones por operaciones significativas

• Solución: Publicar mensajes formateados en canales del equipo con nombres de archivos y resúmenes de cambios

“Extrae información de archivos de la entrada del hook y filtra por tipos relevantes como código fuente o archivos de configuración. Usa la API de Claude para generar un resumen legible de lo que cambió según nombres y tipos. Envía el mensaje formateado a Slack con webhooks y menciones a miembros del equipo para cambios críticos.”

Dispatcher de webhooks

• Problema: Disparadores manuales de CI/CD que retrasan despliegues

• Disparadores: Cuando ocurren eventos específicos (cambios de config, modificación de archivos de despliegue)

• Solución: Llamar a APIs externas para lanzar builds, despliegues u otros procesos automatizados

“Compara la ruta modificada con patrones como Dockerfile, package.json o configuraciones de despliegue para determinar si hay que disparar CI/CD. Usa la librería requests en Python para llamar a webhooks con cabeceras de autenticación y datos sobre los cambios. Incluye rutas y metadatos en el payload para que los sistemas externos decidan qué construir o desplegar.”

Actualizador de status page

• Problema: Los clientes no se enteran de mantenimientos o despliegues

• Disparadores: Cuando se modifican archivos de despliegue o infraestructura

• Solución: Actualizar páginas de estado del servicio con avisos de mantenimiento

“Analiza entradas del hook para cambios en archivos de infraestructura como manifiestos de Kubernetes o configuraciones de Terraform, usando patrones de rutas. Genera mensajes de mantenimiento con la API de Claude según el tipo de cambio detectado. Publica actualizaciones en servicios como StatusPage.io o PagerDuty con sus APIs REST, el tipo de incidente y la duración estimada.”

Notificador de estado del equipo

• Problema: Conflictos cuando varios desarrolladores trabajan en las mismas funcionalidades sin saberlo

• Disparadores: Al iniciar una nueva sesión de Claude Code

• Solución: Avisar a los canales del equipo de que empiezas a trabajar en un proyecto o componente concreto

“Lee el directorio del proyecto de la entrada del hook y usa la API de Claude para analizar archivos recientes o el historial de git y entender el tipo de trabajo. Envía un mensaje formateado a los canales del equipo con tu nombre, el proyecto y el área de foco. Incluye duración estimada e invita a coordinar a quien trabaje en funcionalidades relacionadas.”

Conclusiones

Los hooks de Claude Code convierten a un asistente de programación impredecible en flujos automatizados que se ejecutan justo cuando los necesitas. En este tutorial has aprendido a configurar hooks con el comando interactivo /hooks y mediante configuración manual, a entender los datos de entrada en JSON que alimentan la automatización inteligente y a controlar el comportamiento de Claude con códigos de salida y salidas estructuradas. 

Entre los patrones prácticos que hemos visto hay validadores de seguridad que bloquean operaciones peligrosas y notificaciones inteligentes que reducen el ruido. Estos ejemplos muestran cómo los hooks resuelven problemas reales de desarrollo y te dan control total sobre tu asistente de IA. Ahora que dominas los fundamentos, puedes crear automatizaciones adaptadas al flujo de trabajo de tu equipo. 

Para seguir aprendiendo a trabajar con herramientas de IA, consulta el curso de DataCamp Understanding Prompt Engineering, que cubre estrategias de prompting que encajan directamente con el desarrollo de hooks. Para habilidades más amplias de programación con IA, prueba nuestro curso Intermediate ChatGPT y desarrolla las habilidades que hacen que los asistentes de IA sean socios más fiables en tu flujo de desarrollo.