Ganchos Claude Code: Guía práctica para la automatización de flujos de trabajo

Cuando trabajas con Claude Code, notarás un problema común: Escribes buen código, pero olvidas pasos importantes como el formateo, la ejecución de pruebas o el cumplimiento de los protocolos de seguridad. Terminas repitiendo los mismos recordatorios una y otra vez. 

Claude Code Hooks te permite automatizar estos recordatorios ejecutando comandos de terminal automáticamente en puntos específicos de tu flujo de trabajo.

Este tutorial te muestra cómo configurar ganchos para el formateo de código, la ejecución de pruebas, las notificaciones y la protección de archivos. Crearás un sistema de automatización que aplique tus estándares de desarrollo de forma coherente sin intervención manual.

Para obtener más información sobre el modelo de lenguaje grande (LLM) que impulsa Claude Code, consulta este artículo sobre Claude Sonnet 4.5.

¿Qué son los ganchos de código Claude?

Los Claude Code Hooks son comandos de terminal que se ejecutan automáticamente cuando se producen eventos específicos durante tu sesión de programación de IA. Piensa en ellos como desencadenantes automatizados que ejecutan tus scripts personalizados en momentos precisos:antes de que Claude escriba un archivo, después de que ejecute un comando o cuando te envíe una notificación.

El sistema funciona supervisando las acciones de Claude Code y comparándolas con las reglas que tú defines en un archivo de configuración. Cuando se produce una coincidencia, el comando especificado se ejecuta con acceso al contexto de lo que acaba de suceder. Esto te permite controlar el comportamiento de Claude y automatizar tareas repetitivas que, de otro modo, requerirían una intervención manual.

Aquí tienes un gancho básico que ejecuta un formateador de código cada vez que Claude escribe un archivo Python:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}

Este gancho tiene tres partes: 

• El evento: PostToolUse (después de que Claude termine una acción)

• El comparador: Write (solo al escribir archivos)

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

El hook recibe información detallada sobre lo que Claude acaba de hacer a través de datos JSON enviados a la entrada del script, por lo que puedes crear una automatización más sofisticada que responda a cambios específicos en los archivos.

Si te interesa la automatización más allá de los flujos de trabajo de codificación, Claude Cowork ofrece una automatización similar asistida por IA para tareas relacionadas con archivos y documentos.

A continuación, exploraremos cómo crear estos ganchos desde cero y registrarlos en Claude Code para añadirlos a tus flujos de trabajo.

Requisitos previos

Antes de sumergirte en Claude Code Hooks, necesitarás configurar algunas cosas:

• Claude Code instalado y en funcionamiento: Debes sentirte cómodo utilizando Claude Code para tareas básicas de programación.

• Familiaridad con la línea de comandos: Los ganchos ejecutan comandos de terminal, por lo que necesitarás saber cómo escribir comandos básicos de terminal para tu sistema operativo.

• Acceso al editor de texto: Tú editarás archivos de configuración JSON para configurar tus hooks.

• Directorio del proyecto: Un proyecto de programación en el que puedes probar los hooks de forma segura sin afectar al trabajo importante.

No es necesario que seas un experto en scripts de terminal, pero comprender cómo ejecutar comandos como ls, cd y operaciones básicas con archivos te ayudará a seguir los ejemplos. Si eres nuevo en la programación de scripts bash o en el terminal, te recomiendo que realices nuestro curso Introducción al terminal .

Introducción a Claude Code Hooks

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

Comprender los eventos de gancho

Claude Code ofrece diez eventos diferentes en los que puedes ejecutar tus comandos. Cada evento se activa en un momento específico, lo que te permite controlar diferentes partes de tu flujo de trabajo:

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, lo que lo hace perfecto para validar o bloquear operaciones peligrosas. PostToolUse se ejecuta después de que Claude completa una acción, lo que funciona bien para tareas de limpieza como formatear código o ejecutar pruebas.

UserPromptSubmit Se activa cuando envías una solicitud a Claude, antes de que esta procese tu petición. Puedes utilizar esto para añadir contexto a tu conversación o validar que las indicaciones cumplen ciertos requisitos.

Notification Se ejecuta cuando Claude te envía alertas, como solicitar permiso para ejecutar un comando o cuando necesita tu intervención. PermissionRequest se activa cuando Claude Code muestra un cuadro de diálogo de permiso, lo que te permite aprobar o denegar automáticamente la solicitud en nombre del usuario.

Stop y SubagentStop se activan cuando Claude termina de responder, lo que resulta útil para realizar comprobaciones finales o generar informes. La diferencia entre ambos es que Stop se activa cuando Claude finaliza su respuesta global, mientras que SubagentStop lo hace cuando un ayudante generado por una herramienta (un «subagente») finaliza su trabajo.

Los eventos restantes, PreCompact y SessionStart, gestionan situaciones especiales como la limpieza de conversaciones y la inicialización de sesiones.

Los eventos restantes, PreCompact, SessionStart y SessionEnd, gestionan situaciones específicas del ciclo de vida. PreCompact se ejecuta justo antes de que Claude acorte el historial de conversaciones. «SessionStart» se activa al comienzo de una nueva sesión para configurar los valores predeterminados, y « SessionEnd » se activa cuando se cierra la sesión, lo que permite realizar tareas de limpieza o generar informes finales.

Comprender los comparadores

Los comparadores son los filtros que deciden qué acciones de Claude Code activan un gancho. Técnicamente, son cadenas interpretadas como expresiones regulares, por lo que puedes utilizar coincidencias exactas o patrones más flexibles. 

Los comparadores más relevantes son los simples, como Write (se activa cuando Claude escribe un archivo) o Edit (se activa al editar contenido), y combinaciones como Edit|Write para cubrir múltiples acciones. 

También puedes utilizar patrones de prefijo como Notebook.* para buscar todas las herramientas que comienzan por «Notebook». Si deseas que el hook se active en cada acción, utiliza la expresión regular universal .*, una cadena vacía ("") o deja matcher en blanco.

Dado que los comparadores distinguen entre mayúsculas y minúsculas y solo actúan sobre nombres de acciones, es mejor que sean lo más específicos posible. Cuando necesites un control más preciso (por ejemplo, limitar el gancho a determinados tipos de archivos), puedes leer la carga JSON que Claude pasa al gancho y aplicar tus propias expresiones regulares o condiciones allí.

Crear tu primer hook en Claude Code

Claude Code ofrece dos formas de configurar los hooks: mediante el comando interactivo « /hooks » o editando directamente los archivos de configuración. Comencemos con el enfoque interactivo, ya que es más adecuado para principiantes.

Usando el comando « /hooks »:

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

2. Elige tu evento desencadenante (selecciona « PostToolUse » para este ejemplo).

3. Selecciona «Añadir nuevo gancho» en el menú.

4. Configura tu patrón de coincidencia (introduce Write para escribir en el archivo de destino).

5. Introduce tu comando:

• Mac: say "Task complete"

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

• Linux: spd-say "Task complete"

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

El comando « /hooks » actualizará automáticamente tu archivo de configuración y volverá a cargar la configuración. También puedes utilizar /hooks en cualquier momento para ver tus ganchos existentes o realizar cambios.

Si prefieres editar los archivos de configuración directamente, los hooks se encuentran en ~/.claude/settings.json para la configuración global o en .claude/settings.json dentro del directorio de tu proyecto. Para nuestro ejemplo anterior, quedaría así:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}

Después de editar el archivo manualmente, reinicia Claude Code o utiliza el comando « /hooks » para volver a cargar tu configuración. Ahora, cada vez que Claude escriba un archivo, escucharás una notificación de audio.

Probando tu gancho

Antes de continuar, comprueba que tu gancho funciona correctamente:

1. Pídele a Claude que escriba cualquier archivo Python (por ejemplo, «Crea un archivo hello.py que imprima hola mundo»).

2. Deberías escuchar la notificación de audio cuando Claude complete la operación de escritura.

3. Si no escuchas nada, comprueba la transcripción de Claude Code pulsando Ctrl-O para ver si hay mensajes de error.

4. Entre los problemas más comunes se incluyen que no se encuentra el comando hook, permisos de archivo incorrectos o errores de sintaxis en tu archivo de configuración.

Hacer que esta prueba básica funcione te ahorrará tiempo de depuración más adelante, cuando crees ganchos más complejos. Si acabas de editar el archivo de configuración manualmente, has cambiado un comparador o un evento, o has instalado nuevas herramientas que deseas utilizar en un comando de gancho, puede ser útil volver a abrir /hooks o reiniciar Claude para volver a cargar la configuración.

Este patrón básico (evento, comparador, comando) constituye la base de toda la automatización de ganchos. Puedes ampliar esto añadiendo varios comandos para que se ejecuten simultáneamente cuando se active el mismo evento. Por ejemplo, es posible que quieras reproducir un sonido y crear una copia de seguridad cuando Claude escriba un archivo. 

También puedes crear comparadores independientes para diferentes herramientas dentro del mismo evento, de modo que la escritura de archivos active acciones diferentes a las de la edición de código. Todos los ganchos que coinciden con el mismo patrón de herramienta funcionan en paralelo. Si configuras varios comparadores para el mismo evento, cada gancho se ejecuta cuando se activa su comparador.

Trabajar con entradas de gancho

Cuando Claude Code activa un gancho, envía información sobre lo que acaba de suceder 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 los que hacen que los hooks sean tan potentes, en lugar de ser simplemente scripts aleatorios que se ejecutan en momentos arbitrarios. 

Claude Code empaqueta esta información como JSON y la envía al comando que hayas configurado, ya sea un simple comando de terminal o un script personalizado.

Anatomía de las entradas de gancho

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"
}

Traduzcamos cada componente:

• session_id: identifica tu conversación actual

• transcript_path: apunta al historial de conversaciones.

• cwd: muestra el directorio de trabajo.

• hook_event_name: te indica qué evento se ha activado.

Disponer de este contexto permite que tus hooks tomen decisiones inteligentes: puedes rastrear qué conversación desencadenó una acción, acceder al historial completo del chat si es necesario o ejecutar comandos en el directorio correcto.

Variaciones de entrada basadas en eventos

Los eventos de herramientas como PreToolUse y PostToolUse incluyen detalles adicionales sobre la acción, que es donde los ganchos resultan realmente útiles para la automatización. En PreToolUse, se especifica tool_input, y tool_response adicionalmente en PostToolUse:

{
  "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
  }
}

En la entrada del gancho, file_path muestra la ruta del archivo que se está escribiendo o editando, 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 el nombre del último archivo modificado ( filePath, fíjate en el camelCase) para confirmar qué archivo se ha modificado realmente, junto con un indicador de estado ( success ) que indica si la operación se ha completado correctamente. 

Esta información detallada significa que tus hooks pueden responder de manera diferente en función de lo que realmente haya ocurrido. Puedes dar formato solo a archivos Python, hacer copias de seguridad solo de directorios importantes o enviar notificaciones solo cuando se modifiquen determinados tipos de archivos.

Los eventos como « UserPromptSubmit » son más sencillos, ya que no requieren herramientas:

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}

Ten en cuenta que los hooks de UserPromptSubmit no utilizan comparadores en su configuración. Se activan con todas las indicaciones, no con las operaciones de las herramientas. Esto los hace perfectos para registrar conversaciones, añadir automáticamente el contexto del proyecto o validar las indicaciones antes de que Claude las procese.

Lectura de la entrada del gancho en la práctica

Creemos un gancho que registre cada solicitud de usuario. Esto resuelve el problema de perder la pista de lo que le pediste a Claude que hiciera, especialmente durante largas sesiones de programación. En primer lugar, la configuración del gancho:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}

A continuación, 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)

El script lee los datos JSON que envía Claude Code y registra el mensaje con el contexto de la sesión. Esto crea un historial de tus interacciones que se puede consultar y que resulta muy valioso cuando necesitas recordar cómo resolviste un problema semanas después.

Trabajar con salidas de gancho

Después de ejecutar el comando hook, es necesario que le comuniques a Claude Code qué ha sucedido y si debe continuar con normalidad. Este mecanismo de control es lo que convierte a los ganchos de simples herramientas de registro en una potente automatización del flujo de trabajo que puede guiar el comportamiento de Claude. Esto 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) significa salida normal. Por ejemplo, si imprimes algo, se envía a stdout. Para la mayoría de los ganchos, esto es lo que aparece en la transcripción de Claude Code cuando presionas Ctrl-O, lo que te proporciona un registro de lo que hizo tu automatización sin saturar la conversación principal.

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

• 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, lo que le permite responder a los problemas que detectan tus hooks.

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

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

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

• Código de salida 3: Ejecución diferida (indica que el comando se completó sin errores, pero sus efectos se posponen hasta que se cumplan condiciones adicionales). 

• Otros códigos: Error sin bloqueo (muestra stderr al usuario, pero continúa funcionando).

Este sistema te ofrece un control preciso sobre cuándo Claude debe detenerse, continuar u obtener comentarios sobre lo que ha descubierto tu automatización. Veamos algunos ejemplos de los dos códigos de salida más importantes.

Código de salida 0: Funcionamiento normal

La mayoría de los ganchos utilizan el código de salida 0 para indicar que todo ha ido bien. Aquí tienes un hook completo que registra las 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')\""
          }
        ]
      }
    ]
  }
}

Este gancho ejecuta dos comandos: registrar en un archivo y, a continuación, imprimir un mensaje en la transcripción. Hay muchas formas de hacerlo, pero este enfoque es multiplataforma y evita depender de los detalles específicos de la línea de comandos.

Como no hay un código de salida explícito, el valor predeterminado es 0. El mensaje impreso aparece en la transcripción de Claude Code, lo que te indica que el registro ha funcionado. Este patrón es perfecto para crear registros de auditoría o realizar un seguimiento de los cambios que Claude realiza en tu proyecto a lo largo del tiempo.

Código de salida 2: Bloqueo con retroalimentación

El código de salida 2 envía tu mensaje de error directamente a Claude, permitiéndole responder automáticamente. Aquí es donde los ganchos se convierten en un mecanismo de seguridad, en lugar de ser solo automatización. Aquí hay un gancho que bloquea las operaciones de archivo peligrosas:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}

Tendrás que crear el script de comprobación 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 transcript

Cuando este gancho detecta una ruta peligrosa, sale con el código 2. Claude Code envía el mensaje stderr a Claude, que luego puede explicarte por qué se bloqueó la operación y sugerirte alternativas. Esto evita daños accidentales en los archivos del sistema y mantiene a Claude informado sobre tus políticas de seguridad.

Creación de un gancho de notificación inteligente para Claude Code

Creemos nuestro gancho de notificación mejorado que combine el procesamiento de entradas con el manejo inteligente de salidas. Esto resuelve el problema del ruido de nuestro gancho original, que alertaba cada vez que se producía un cambio en un archivo:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}

Crea el script de notificación 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)

Este gancho lee la entrada para comprender qué archivo se ha modificado, toma decisiones sobre la importancia de la notificación en función del tipo de archivo, utiliza stdout para registrar los cambios importantes en la transcripción, activa diferentes alertas de audio en función del tipo de archivo y siempre sale con el código 0, ya que se trata de acciones informativas, no bloqueantes.

La combinación del análisis de entradas y el control de salidas crea un gancho que se comporta de forma inteligente en función del contexto, al tiempo que proporciona el nivel adecuado de retroalimentación tanto a ti como a Claude Code. En lugar de recibir molestas notificaciones por cada archivo temporal, solo te informaremos de los cambios que realmente son importantes para tu proyecto.

Ten en cuenta que este ejemplo utiliza el comando « say », que está disponible en macOS. En Linux, puedes utilizar notify-send y, en Windows, un comando de PowerShell para obtener notificaciones similares.

Patrones avanzados para ganchos de código Claude

Más allá de las notificaciones básicas y el registro, los hooks pueden resolver problemas reales del flujo de trabajo de desarrollo a los que se enfrentan los equipos a diario. Aquí tienes algunas ideas que puedes adaptar a tus propios proyectos.

Lo mejor es que, en realidad, no es necesario crear estos ganchos manualmente. Solo tienes que proporcionar a Claude Code una de las ideas que se sugieren a continuación, junto con la referencia a Hooks en su documentación, y generará el código y el JSON pertinentes para la configuración.

Cada uno de estos patrones se puede personalizar para tus herramientas y flujo de trabajo específicos. Empieza por las que resuelven tus mayores frustraciones diarias y, a medida que te sientas más cómodo con el desarrollo de ganchos, amplía tu automatización.

Ganchos avanzados para seguridad y cumplimiento normativo

Escáner de claves API

• Problema: Cometer accidentalmente secretos al control de versiones

• Desencadenantes: Antes de escribir cualquier archivo

• Solución: Escaneo del contenido de archivos en busca de claves API, tokens y contraseñas utilizando patrones regex.

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

Envía solo fragmentos enmascarados (por ejemplo, mantén 4 caracteres prefijos/sufijos) o hash a la API de Anthropic para analizar cadenas sospechosas y determinar si se trata de secretos reales o nombres de variables. Sal con el código 2 y proporciona a Claude información sobre los secretos detectados y alternativas más seguras.

Responsable de la aplicación de la licencia

• Problema: Los proyectos de código abierto carecen de los encabezados de licencia necesarios en los nuevos archivos.

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

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

Analiza la entrada del hook para obtener el contenido del archivo y comprueba si las primeras 10 líneas contienen el texto de la licencia utilizando la coincidencia de cadenas. Para una validación más sofisticada, envía el encabezado del archivo a Claude a través de la API de Anthropic para verificar que contiene los avisos de derechos de autor y la información de licencia adecuados. Bloquea la creación de archivos con el código de salida 2 si faltan los encabezados y proporciona a Claude la plantilla de licencia correcta para añadir.

Protector de archivos de producción

• Problema: Modificación accidental de archivos de configuración críticos del sistema

• Desencadenantes: Antes de editar archivos en directorios confidenciales

• Solución: Bloqueo de 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 de archivos críticos. Utiliza la API de Claude para analizar la ruta del archivo y determinar si se trata de un archivo de configuración que podría afectar a los sistemas de producción. Sal con el código 2 y proporciona orientación específica sobre prácticas de desarrollo más seguras cuando se detecten rutas peligrosas.

Optimizador de imágenes

• Problema: Los archivos de imagen de gran tamaño ralentizan las aplicaciones y los repositorios.

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

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

Analiza la entrada del hook para obtener la ruta del archivo y comprueba si se trata de un archivo de imagen utilizando la coincidencia de extensiones. Ejecuta herramientas de compresión como imageoptim o llama a la API de TinyPNG para comprimir la imagen sin perder calidad. Registra los resultados de la compresión en stdout para que puedas ver el ahorro de tamaño de archivo en la transcripción de Claude.

Ganchos avanzados para la automatización del control de versiones

Validador de ramas Git

• Problema: Los miembros del equipo envían accidentalmente cambios a ramas protegidas.

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

• Solución: Comprobación de la rama Git actual y bloqueo de operaciones en main/master/production.

Utiliza un sencillo comando bash git branch --show-current para obtener el nombre de la rama actual y compararlo con una lista de ramas protegidas. Si estás en una rama protegida, sal con el código 2 y envía a Claude un mensaje de error explicando las políticas de protección de ramas. Para reglas complejas de nomenclatura de ramas, utiliza la API de Claude para analizar los nombres de las ramas y determinar si coinciden con los patrones de protección.

Autocomprobación inteligente

• Problema: Olvidar confirmar los cambios o escribir mensajes de confirmación deficientes.

• Desencadenantes: Después de cualquier modificación del archivo

• Solución: Puesta en escena y confirmación automáticas de los cambios con mensajes descriptivos generados por IA.

Lee las rutas de los archivos modificados desde la entrada del hook, ejecuta « git diff » para obtener los cambios y envía el diff a la API de Claude con un mensaje solicitando un mensaje de confirmación conciso. Utiliza el mensaje generado con los comandos « git add » y « git commit » para confirmar automáticamente los cambios. Incluye los nombres de los archivos y los tipos de cambios en el mensaje de la API para garantizar que los mensajes de confirmación sigan los estándares convencionales de confirmación.

Generador de documentación

• Problema: La documentación de la API deja de estar sincronizada con los cambios en el código.

• Desencadenantes: Después de modificar los archivos de interfaz (controladores, modelos, API)

• Solución: Ejecutar automáticamente herramientas de documentación como JSDoc, Sphinx o generadores OpenAPI.

Comprueba la ruta del archivo modificado para determinar si se trata de un punto final de API, un modelo o un archivo de interfaz utilizando la coincidencia de patrones. Envía el contenido del archivo a la API de Claude y solicítale que extraiga los cambios de la API y genere actualizaciones de la documentación. Ejecuta la herramienta de generación de documentación adecuada (jsdoc, sphinx-build, etc.) y envía automáticamente la documentación actualizada.

Ganchos avanzados para la colaboración y la integración del flujo de trabajo

Integración con Slack

• Problema: El equipo no está al tanto de cambios importantes en los códigos base compartidos.

• Desencadenantes: Cuando se envían notificaciones para operaciones importantes

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

Extrae la información de los archivos de la entrada del hook y filtra los tipos de archivos importantes, como el código fuente o los archivos de configuración. Utiliza la API de Claude para generar un resumen legible sobre los cambios realizados en función de los nombres y tipos de archivo. Envía el mensaje formateado a Slack utilizando URL de webhook con menciones a los miembros del equipo para cambios críticos.

Distribuidor de webhooks

• Problema: Los desencadenantes manuales del proceso de CI/CD provocan retrasos en la implementación.

• Desencadenantes: Cuando se producen eventos específicos (cambios en la configuración, modificación de los archivos de implementación)

• Solución: Llamar a API externas para activar compilaciones, implementaciones u otros procesos automatizados.

Comprueba la ruta del archivo modificado con patrones como Dockerfile, package.json o configuraciones de implementación para determinar si se debe activar CI/CD. Utiliza la biblioteca de solicitudes de Python para llamar a las URL de webhook con encabezados de autenticación y datos de carga útil sobre los cambios. Incluye rutas de archivos y cambia los metadatos en la carga útil del webhook para que los sistemas externos puedan tomar decisiones inteligentes sobre qué crear o implementar.

Actualizador de la página de estado

• Problema: Los clientes no están al tanto de las actividades de mantenimiento o implementación.

• Desencadenantes: Cuando se modifican los archivos de implementación o infraestructura

• Solución: Actualiza las páginas de estado del servicio con notificaciones de mantenimiento.

Analizar la entrada del gancho para detectar cambios en los archivos de infraestructura, como los manifiestos de Kubernetes o las configuraciones de Terraform, utilizando patrones de ruta de archivo. Genera mensajes de mantenimiento utilizando la API de Claude en función del tipo de cambios detectados en la infraestructura. Publicar actualizaciones de estado en servicios como StatusPage.io o PagerDuty utilizando sus API REST con los tipos de incidencia adecuados y la duración estimada.

Notificador del estado del equipo

• Problema: Conflictos cuando varios programadores trabajan en las mismas funciones sin saberlo.

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

• Solución: Avisar a los canales del equipo que estás comenzando a trabajar en un proyecto o componente específico.

Lee el directorio del proyecto desde la entrada del hook y utiliza la API de Claude para analizar los archivos recientes o el historial de git y comprender qué tipo de trabajo se está realizando. Envía un mensaje formateado a los canales de comunicación del equipo con tu nombre, el nombre del proyecto y el área de interés. Incluye la duración estimada del trabajo e invita a los miembros del equipo a coordinarse si están trabajando en funciones relacionadas.

Conclusión

Claude Code Hooks convierte los impredecibles asistentes de codificación de IA en flujos de trabajo automatizados que se ejecutan exactamente cuando los necesitas. En este tutorial, has aprendido a configurar hooks utilizando tanto el comando interactivo /hooks como la configuración manual, a comprender los datos de entrada JSON que impulsan la automatización inteligente y a controlar el comportamiento de Claude a través de códigos de salida y salidas estructuradas. 

Los patrones prácticos que hemos visto incluyen 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, al mismo tiempo, te brindan un control total sobre tu asistente de IA. Ahora que ya conoces los fundamentos, puedes crear una automatización que se adapte a las necesidades específicas del flujo de trabajo de tu equipo. 

Para obtener más información sobre cómo trabajar con herramientas de IA, consulta el curso «Comprender la ingeniería de prompts» de DataCamp. Comprender la ingeniería de indicaciones, que abarca estrategias de prompts que funcionan directamente con el desarrollo de hooks. Para ampliar tus conocimientos de programación en IA, prueba nuestro curso intermedio de chatGPT para desarrollar las habilidades que hacen que los asistentes de IA sean socios más fiables en tu flujo de trabajo de desarrollo.