AI Coding Agents: Rules, Commands, Skills, MCP y Hooks explicados : AntonioCortes.com

Si estás usando herramientas como Claude Code, GitHub Copilot Workspace o similares, habrás notado que hay una jerga técnica que va más allá de simplemente “chatear con la IA”. Hablo de términos como rules, commands, skills, MCP y hooks.

Estos conceptos son la arquitectura que hace que los agentes de IA sean realmente útiles para desarrollo de software. No son solo palabras bonitas de marketing — cada uno cumple una función específica en cómo el agente trabaja.

Vamos a desglosarlos uno por uno de forma clara.

Antes de nada: ¿Qué es un AI Coding Agent?

Un AI coding agent es un sistema que no solo responde preguntas, sino que ejecuta acciones en tu códigobase. Puede leer archivos, modificar código, ejecutar comandos, y tomar decisiones basadas en contexto.

La diferencia clave con un chatbot normal: un agent tiene herramientas y puede operar autónomamente dentro de ciertos límites.

Ahora, vamos con los conceptos que hacen funcionar a estos agentes.

Rules: Las instrucciones permanentes

Las rules (reglas) son instrucciones que configuramos una vez y el agente las respeta siempre, en cada interacción. Piensa en ellas como la configuración global del agente.

Para qué sirven

Las rules definen:

Qué debe hacer el agente
Qué NO debe hacer (limitaciones)
Cómo comportarse en situaciones específicas
Formatos de salida preferidos
Precauciones de seguridad

Ejemplo real

Imagina que estás trabajando en un proyecto Laravel y tienes una rule que dice:

Usar siempre factories de Laravel para generar datos de prueba, nunca usar datos hardcoded o inserts SQL directos.

Esto significa que cada vez que el agente necesita crear tests o datos de ejemplo, automáticamente usará factories sin que tengas que recordárselo.

Cuándo usar rules

Usa rules cuando:

✅ Tienes restricciones que se aplican siempre
✅ Quieres consistencia en todas las respuestas
✅ Necesitas guard rails para evitar comportamientos indeseados
✅ Tienes preferencias de formato que deben respetarse siempre

Dónde se configuran

Dependiendo de la herramienta, las rules pueden estar en:

Archivos de configuración (ej: CLAUDE.md para Claude Code)
Settings de la aplicación
Archivos de proyecto específicos

Commands: Atajos para tareas recurrentes

Los commands son atajos predefinidos que ejecutan una tarea específica. Son como macros: un comando que dispara una secuencia compleja de acciones.

Cómo funcionan

Cuando invocas un command, el agente:

Expande el comando en su prompt completo
Ejecuta la tarea asociada
Te devuelve el resultado

Ejemplo real

Si tienes un command /commit, el agente podría:

Leer el estado de git
Analizar los cambios
Generar un mensaje de commit descriptivo
Ejecutar git commit con ese mensaje

Todo esto con un solo comando: /commit.

Tipos de commands

Hay dos categorías principales:

1. Built-in commands (viene con la herramienta)

/help - Muestra ayuda
/clear - Limpia contexto
/commit - Crea commits (en algunas herramientas)

2. Custom commands (los defines tú)

/review - Revisa el código actual
/test - Genera tests para lo que estás editando
/deploy - Ejecuta tu pipeline de deployment

Ventajas de usar commands

Velocidad: No tienes que escribir el mismo prompt una y otra vez
Consistencia: Siempre se hace de la misma manera
Documentación: Los commands sirven como documentación de tu flujo de trabajo
Complejidad oculta: Puedes encadenar muchas acciones en un command simple

Cuándo crear commands

Crea commands para:

✅ Tareas que repites frecuentemente
✅ Procesos multit-step que siempre se hacen igual
✅ Flujos de trabajo complejos que quieres simplificar

Skills: Capacidades especializadas

Las skills son paquetes de conocimiento y capacidades que un agente puede cargar bajo demanda. Piensa en ellas como plugins o extensiones: el agente las tiene disponibles, pero solo las usa cuando las necesitas.

Diferencia vs commands

Commands: Ejecutan una tarea específica
Skills: Añaden capacidades nuevas al agente

Una skill puede incluir múltiples commands, rules y lógica especializada.

Ejemplo real

Una skill de “code-review” podría incluir:

Conocimiento sobre patrones de código limpio
Rules para qué verificar primero
Commands para análisis de seguridad
Lógica para priorizar issues críticos
Formato específico de reportes

Skills comunes en herramientas actuales

Git management: Commits, branches, PRs
Testing: Generación de tests, ejecución, cobertura
Documentation: Generar docs, actualizar READMEs
Security: Scanning de vulnerabilidades
Refactoring: Mejorar código existente
Database: Migrations, queries, optimización

Por qué las skills importan

Las skills permiten:

Especialización: El agente sabe de dominios específicos
Composicionabilidad: Combina skills para tareas complejas
Actualización: Puedes mejorar skills independientemente
Compartir: Puedes distribuir skills a tu equipo

Cuándo usar skills

Usa skills cuando:

✅ Un dominio requiere conocimiento especializado
✅ Quieres compartir capacidades entre diferentes agentes
✅ Necesitas actualizar conocimiento sin cambiar el core

MCP: Model Context Protocol

MCP (Model Context Protocol) es un estándar abierto que permite que los agentes de IA se conecten con herramientas externas y fuentes de datos de manera estandarizada.

El problema que resuelve

Antes de MCP, cada herramienta de IA tenía su propio formato para conectarse con cosas:

Leer archivos del filesystem
Consultar bases de datos
Hacer llamadas HTTP
Ejecutar comandos

Era un caos. Cada integración era ad-hoc.

La solución MCP

MCP define:

Cómo el agente se comunica con una herramienta
Qué información se pasa (inputs/outputs)
Cómo se manejan errores
Cómo se descubren capacidades disponibles

Ejemplo real

Imagina un servidor MCP que expone acceso a tu base de datos:

# El servidor MCP expone herramientas
tools:
  - name: "query_database"
    description: "Ejecuta queries SQL en la base de datos"
    input_schema:
      type: "object"
      properties:
        query:
          type: "string"
          description: "Query SQL a ejecutar"

El agente puede:

Descubrir que existe esta herramienta
Saber cómo usarla (qué inputs acepta)
Ejecutar queries de forma segura
Recibir resultados estructurados

Servidores MCP

Un servidor MCP es un programa que expone funcionalidad a través del protocolo MCP. Puede ser:

Local: Corre en tu máquina
Remoto: Corre en un servidor
Hybrid: Mix de ambos

Ejemplos de servidores MCP:

Filesystem: Leer/escribir archivos
Database: Consultas SQL
Git: Operaciones de repositorios
API: Calls a servicios externos
Memory: Almacenamiento persistente para el agente

Ventajas de MCP

Estándar abierto: No estás vendor-locked
Comunidad: Hay cientos de servidores MCP ya creados
Seguridad: Controlas qué herramientas puede usar el agente
Composibilidad: Combina múltiples servidores MCP
Extensible: Fácil crear nuevos servidores

Por qué MCP es importante para AI Coding Agents

MCP permite que los agentes:

Lean tu código (filesystem server)
Entiendan tu git history (git server)
Consulten documentación (docs server)
Ejecuten tests (test runner server)
Se conecten a APIs (HTTP server)

Todo esto de forma estandarizada y segura.

Hooks: Personalización basada en eventos

Los hooks son puntos de inserción donde puedes ejecutar lógica personalizada en respuesta a eventos específicos del ciclo de vida del agente.

Cómo funcionan

Un hook se define como:

Cuándo ejecutarse (qué evento)
Qué ejecutar (comando o script)
Cómo usar el resultado (modificar comportamiento)

Ejemplo real

Un hook pre-commit podría:

Detectar que el agente va a hacer un commit
Ejecutar un linter sobre los archivos cambiados
Si hay errores, prevenir el commit
Si está todo bien, permitir el commit

Tipos de hooks comunes

1. Lifecycle hooks

before-work - Antes de empezar una tarea
after-work - Después de completar una tarea
before-edit - Antes de modificar un archivo
after-edit - Después de modificar un archivo

2. Event hooks

on-error - Cuando algo falla
on-success - Cuando algo tiene éxito
on-retry - Cuando se reintenta algo

3. Tool-use hooks

before-command - Antes de ejecutar un comando
after-command - Después de ejecutar un comando
before-tool-use - Antes de usar una herramienta
after-tool-use - Después de usar una herramienta

Para qué usar hooks

Los hooks son útiles para:

Validación: Verificar que el agente haga lo correcto
Logging: Registrar qué hace el agente
Modificación: Cambiar comportamiento basándose en contexto
Integración: Conectar con herramientas externas
Seguridad: Prevenir acciones peligrosas

Ejemplo de hook de audio (mi configuración personal)

Un uso práctico de hooks es recibir feedback auditivo cuando el agente realiza acciones. En mi configuración de Claude Code tengo hooks que reproducen sonidos:

{
  "hooks": {
    "Notification": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Funk.aiff"
          }
        ]
      }
    ],
    "Stop": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Hero.aiff"
          }
        ]
      }
    ]
  }
}

Esto significa:

Cada vez que hay una notificación, suena un sonido “Funk”
Cuando el agente termina su trabajo, suena un sonido “Hero”

Es una forma simple pero efectiva de saber qué está haciendo el agente sin tener que mirar la pantalla constantemente.

Ejemplo de hook de seguridad

hooks:
  before-tool-use:
    - if: tool.name == "bash" && command.contains("rm -rf")
      then: block("No se permite rm -rf sin confirmación explícita")

Este hook previene que el agente ejecute comandos peligrosos sin aprobación.

Hooks vs Rules

Aspecto	Rules	Hooks
Cuándo se aplican	Siempre, en cada interacción	En eventos específicos
Propósito	Comportamiento general	Respuesta a eventos
Flexibilidad	Estáticas	Dinámicas, pueden evaluar contexto
Ejemplo	“No uses palabras en imágenes”	“Antes de ejecutar bash, verifica el comando”

Cómo todo funciona junto

Lo interesante no es cada concepto por separado, sino cómo trabajan juntos.

Ejemplo: Un flujo completo de trabajo

Imagina que le dices a tu agente: “Añade autenticación a este endpoint API”.

Esto podría disparar:

Hook before-work: Verifica que tienes los permisos necesarios
Rule: El agente sabe que debe usar JWT, no sesiones (configuración global)
Command /auth-boilerplate: Expande un template de código de autenticación
Skill laravel-auth: Aplica conocimiento específico de Laravel
MCP server docs: Consulta la documentación oficial de Laravel
MCP server git: Verifica que no estás modificando archivos protegidos
Hook after-edit: Ejecuta tests automáticos después de cada archivo modificado
Hook before-command: Antes de ejecutar php artisan migrate, pide confirmación

Todo esto sin que tú tengas que especificar cada paso.

Analogía final: El agente como un desarrollador junior

Para entenderlo todo junto, piensa en un agente de IA como un desarrollador junior muy capaz:

Rules = Las guidelines de tu equipo (coding standards, procesos)
Commands = Los scripts y atajos que usas a diario
Skills = Las tecnologías especializadas que conoce (React, Laravel, Docker)
MCP = Las herramientas que tiene disponibles (IDE, terminal, APIs)
Hooks = Los code reviews y checkpoints durante el desarrollo

La diferencia es que este “junior”:

Trabaja 24/7
No se cansa
Ejecuta instantáneamente
Tiene acceso a todo tu códigobase a la vez
Puede leer documentación más rápido que cualquier humano

Herramientas que usan estos conceptos

Claude Code

Rules: Archivos CLAUDE.md y CLAUDE.local.md
Commands: /commit, /help, etc.
Skills: Integradas, con más en camino
MCP: Soporte completo para servidores MCP
Hooks: Configurables para eventos del ciclo de vida

GitHub Copilot Workspace

Rules: Configuración por repositorio
Commands: Flujos de trabajo predefinidos
Skills: Integradas con GitHub ecosystem

Cursor

Rules: Configuración por proyecto
Commands: Atajos personalizables
MCP: Soporte growing

Conclusión

Rules, commands, skills, MCP y hooks no son solo jerga técnica. Son los building blocks que hacen que los agentes de IA sean útiles para desarrollo de software real.

Entender estos conceptos te permite:

Configurar mejor tus herramientas
Automatizar flujos de trabajo repetitivos
Integrar el agente con tu stack existente
Mantener control sobre qué hace el agente

La IA no va a reemplazar a los desarrolladores. Pero los desarrolladores que entiendan cómo configurar y usar estos agentes serán mucho más productivos.

En 2026, entender cómo trabajar con agentes de IA es cada vez más valioso.