Claude Code para Hackers: Ciberseguridad con Agentes IA

Instala Claude Code en Kali Linux siguiendo el principio de mínimo privilegio, tal como lo haría un equipo de seguridad profesional. En esta clase práctica aprenderás a instalar Claude Code en Kali —una distribución basada en Debian— usando el instalador nativo oficial que no requiere Node.js, y entenderás por qué el instalador se niega a ejecutarse como root de forma predeterminada y qué significa eso para tu flujo de trabajo. Verás por qué instalar y usar Claude Code con el usuario kali no privilegiado es la opción correcta, cómo forzar la instalación para root con CLAUDE_INSTALL_ALLOW_SUDO solo cuando de verdad lo necesitas, y por qué ejecutar un agente de IA como root es un riesgo de seguridad que conviene evitar. Completarás la instalación con la verificación de rigor: claude --version, claude doctor, la comprobación de integridad de la clave GPG oficial, y la solución al problema de poca memoria RAM en máquinas virtuales de Kali mediante un archivo swap. Al terminar tendrás Claude Code funcionando en tu entorno de pentesting, instalado de forma segura y lista para las prácticas ofensivas y defensivas del curso. Ideal para pentesters, analistas y estudiantes de ethical hacking que ya trabajan en Kali Linux.

Antes de escribir tu primer prompt, necesitas entender qué es realmente Claude Code y por qué está cambiando la forma en que trabajan los equipos de seguridad. En esta clase introductoria descubrirás que Claude Code no es "otro chatbot": es una plataforma agéntica que vive en tu terminal, lee tu código, ejecuta comandos, se conecta a tus herramientas mediante MCP y encadena tareas de varios pasos, siempre bajo tu aprobación.

Verás por qué ese salto —de un asistente que responde a un agente que actúa— es tan relevante en ciberseguridad, tanto del lado defensivo (code review, análisis de vulnerabilidades, threat intelligence, respuesta a incidentes) como del lado ofensivo autorizado (reconocimiento, enumeración y análisis asistido). Entenderás el modelo de permisos que mantiene el control en manos del analista, las superficies donde corre Claude Code (terminal, IDE, escritorio, CI/CD) y cómo encaja en el flujo de trabajo real de un equipo de seguridad.

Al terminar tendrás una visión clara del impacto de los agentes de IA en la seguridad ofensiva y defensiva, y de por qué dominar Claude Code se está volviendo una habilidad clave para cualquier profesional del área. Esta es la base conceptual sobre la que se construye todo el curso.

Si Claude Code, ChatGPT y GitHub Copilot pueden "escribir código", ¿en qué se diferencian realmente? En esta clase vas a entender la respuesta a nivel de arquitectura, que es lo que de verdad importa para tu trabajo en seguridad.

Verás el eje que ordena todo el panorama: "asistir vs. delegar" (o copilot vs. autopilot). ChatGPT nació como un asistente conversacional de propósito general: tú preguntas, él responde en una ventana de chat. Copilot nació dentro del IDE como autocompletado inteligente —el ghost text que aparece mientras escribes— y hoy le suma un modo agente. Claude Code, en cambio, fue diseñado de origen como un agente: vive en tu terminal (e IDE, escritorio y CI/CD), entiende el repositorio completo y trabaja en un loop de "leer, decidir, ejecutar y verificar" hasta cumplir el objetivo.

También abordaremos la realidad de 2026 con honestidad: las tres herramientas han convergido, y hoy Copilot también ofrece modo agente, CLI, soporte MCP y hooks. Por eso la comparación se centra en las diferencias arquitectónicas que permanecen: dónde se ejecuta el agente, qué tanto contexto maneja, qué familia de modelos usa y cuánta integración nativa de seguridad ofrece (MCP, hooks, subagentes). Entenderás por qué, para un equipo de seguridad que necesita revisar todo un codebase, aplicar gates automáticos y auditar cada acción, la arquitectura agéntica y nativa de Claude Code marca una diferencia concreta.

Al terminar sabrás clasificar cada herramienta por su diseño —no por su marketing— y elegir la adecuada según la tarea de seguridad que tengas enfrente.

Ya sabes que Claude Code es un agente. En esta clase abrimos el capó para ver cómo funciona por dentro, porque entender su ciclo interno es lo que te permite supervisarlo con criterio, confiar en su trabajo y auditarlo, algo esencial en seguridad.

Verás el corazón de Claude Code: el loop agéntico, un ciclo de tres fases que se repite hasta terminar la tarea: reunir contexto (leer y buscar en tu código), actuar (editar archivos y ejecutar comandos) y verificar resultados (correr tests, revisar el build, leer la salida). Entenderás que este loop lo mueven dos componentes —un modelo que razona y las tools que actúan— y que tú también eres parte del ciclo, porque puedes interrumpir y redirigir en cualquier momento.

Después abordaremos la parte que muchos ignoran y que en seguridad es crítica: la gestión del contexto. La ventana de contexto es la memoria de trabajo del agente, y cuando se llena, su precisión se degrada. Verás cómo Claude Code lo resuelve con la compactación —que resume el historial conservando lo esencial— y con los retries, es decir, cómo el agente se autocorrige cuando una acción no pasa la verificación. Y cerrarás entendiendo cómo "recuerda": qué sobrevive a una compactación y por qué el archivo de memoria CLAUDE.md es la base persistente entre sesiones.

Al terminar sabrás explicar, paso a paso, qué ocurre dentro de Claude Code entre que le das una instrucción y obtienes un resultado, y por qué ese diseño importa cuando el agente trabaja sobre un codebase grande y sensible.

Aprende a elegir el modo de operación correcto de Claude Code según el nivel de riesgo de cada tarea de seguridad. En esta clase práctica dominarás los tres modos que decides con la tecla Shift+Tab o con el flag --permission-mode: el modo Default, que pide tu confirmación antes de editar archivos o ejecutar comandos y es el más seguro para código no confiable; el modo Plan, de solo lectura, donde Claude Code investiga y te propone un plan paso a paso sin tocar nada hasta que lo apruebas, ideal para entender un repositorio desconocido o mapear su superficie de ataque; y el modo Auto-Accept (acceptEdits), que agiliza el trabajo auto-aprobando las ediciones de archivos dentro de tu directorio mientras sigue pidiéndote permiso para los comandos del sistema. Verás con qué tarea real de ciberseguridad encaja cada modo, cómo cambiar entre ellos en plena sesión, cómo fijar un modo por defecto, y por qué el modo más permisivo (bypassPermissions) solo debe usarse dentro de un entorno aislado. Al terminar sabrás calibrar cuánta autonomía darle al agente en cada situación, aplicando el principio de mínimo privilegio a tu flujo de trabajo diario. Ideal para analistas, pentesters y equipos de SOC que quieren usar Claude Code de forma rápida sin sacrificar el control.

Claude Code no es solo el agente base: su verdadero poder aparece cuando lo extiendes. En esta clase verás, de un vistazo, los cinco building blocks (bloques de construcción) que convierten a Claude Code en un sistema de seguridad completo, y cómo se integran entre sí.

Recorreremos los cinco: la memoria (el archivo CLAUDE.md), que da al agente contexto persistente y lo convierte en un analista de seguridad; las skills, capacidades reutilizables que el agente invoca cuando las necesita (análisis estático, detección de secrets, revisión de infraestructura); MCP, el protocolo que conecta al agente con tus herramientas externas (Shodan, VirusTotal, un SIEM, escáneres de vulnerabilidades); los subagentes, que permiten orquestar un equipo de agentes en paralelo con contexto aislado; y los hooks, gates automáticos que interceptan y controlan cada acción del agente de forma determinista.

Lo importante no es cada pieza por separado, sino verlas como un sistema: la memoria define el criterio, las skills aportan las capacidades, MCP trae los datos externos, los subagentes reparten el trabajo y los hooks ponen los controles de seguridad. Entenderás cómo encajan y en qué orden conviene adoptarlas.

Esta clase es el mapa del resto del curso: cada building block que veas aquí se desarrollará en profundidad, con labs prácticos, en su propia sección. Al terminar tendrás una visión clara de hacia dónde vamos y por qué cada pieza importa.

En seguridad, un buen prompt es la diferencia entre un hallazgo accionable y una respuesta inútil o, peor, una alucinación que te hace perder el tiempo. En esta clase aprenderás los seis patrones de prompt engineering más efectivos para tareas de seguridad, todos basados en las técnicas oficiales de Anthropic y adaptados a tu trabajo.

Recorreremos los seis: (1) rol y contexto, para activar el razonamiento de un analista de seguridad senior; (2) instrucciones claras y restricciones, para fijar el alcance autorizado y lo que el agente no debe hacer; (3) ejemplos few-shot, para mostrarle exactamente el formato de salida que esperas; (4) salida estructurada, para producir hallazgos parseables con severidad y remediación, listos para tu pipeline; (5) razonamiento paso a paso, para que el agente piense antes de emitir un veredicto en análisis complejos; y (6) encadenar tareas, para descomponer un trabajo grande (como una revisión de seguridad de cinco pasos) en prompts secuenciales más fiables.

También veremos un principio transversal clave en seguridad: darle permiso al agente para decir "no lo sé", porque una respuesta segura pero equivocada es más peligrosa que una duda honesta. Y pondremos en contexto una realidad de 2026: con los modelos actuales, las etiquetas XML siguen siendo útiles para automatizar, pero ya no son obligatorias; unas instrucciones claras logran lo mismo.

Aprende a construir prompts reutilizables que convierten a Claude Code en un revisor de seguridad que entrega hallazgos estructurados, no párrafos vagos. En esta clase práctica dominarás los patrones de prompt para análisis de vulnerabilidades y code review: cómo darle un rol y un contexto de seguridad claros, cómo imponer restricciones, y cómo exigir un esquema de salida fijo para que cada hallazgo incluya ubicación exacta (archivo y línea), clase de vulnerabilidad según CWE y OWASP, severidad, vector y puntaje CVSS, y pasos de remediación accionables. Trabajarás con CVSS 4.0, el estándar actual, entendiendo también por qué conviene reportar CVSS 3.1 en paralelo, y generarás salidas listas para pegar en un reporte o para consumir en un pipeline (tablas Markdown o JSON). Verás cómo usar el modo Plan para revisar repositorios grandes sin riesgo, cómo pedir evidencia y razonamiento para poder verificar los resultados, y por qué nunca debes confiar a ciegas en el puntaje CVSS que produce un modelo. Al terminar tendrás una batería de plantillas de prompt probadas que hacen tu code review más rápido, consistente y defendible. Ideal para analistas de AppSec, pentesters, revisores de código y equipos de SOC.

Aprende a construir prompts reutilizables que convierten reportes de amenazas, logs y correos de phishing en indicadores de compromiso (IOCs) limpios y estructurados. En esta clase práctica dominarás los tres patrones centrales del trabajo de threat intelligence con Claude Code: extraer IOCs de texto no estructurado —incluyendo indicadores "defanged" como hxxp y dominios con corchetes—, clasificarlos por tipo, sensibilidad TLP, nivel de confianza, familia de malware y técnica de MITRE ATT&CK, y enriquecerlos y normalizarlos para dejarlos listos para tu plataforma. Aprenderás a exigir salidas estructuradas en JSON, CSV o formato compatible con STIX/MISP para alimentar un pipeline; a validar los indicadores (longitud correcta de hashes, descarte de IPs privadas o reservadas) y a deduplicarlos; y a aplicar la disciplina profesional de conservar el contexto y la fuente de cada indicador y volver a "defang" antes de compartir para evitar clics accidentales. Verás por qué la extracción con un buen prompt supera a las expresiones regulares frágiles, y prepararás el terreno para las próximas clases, donde conectarás Claude Code a fuentes de enriquecimiento en vivo mediante MCP. Ideal para analistas de threat intelligence, equipos de SOC y respondedores de incidentes.

Aprende a orientar a Claude Code en tareas sensibles de seguridad dándole el contexto correcto: un rol claro, restricciones explícitas y ejemplos que fijan el resultado esperado. En esta clase práctica entenderás las tres piezas del contexto efectivo y, sobre todo, dónde vive cada una. Verás cómo usar el CLAUDE.md como memoria persistente del proyecto para definir el rol del agente (por ejemplo, revisor de AppSec) y sus restricciones (qué no debe tocar, qué alcance respetar), cómo aplicar ejemplos few-shot para que la salida siga siempre el formato que necesitas, y cómo los output styles ajustan la forma de comunicar sin alterar lo que el agente sabe. Aprenderás la regla de oro para decidir qué información va en la memoria persistente y qué va en el prompt de cada sesión, cómo escribir restricciones que el agente respete de verdad, y por qué el contexto orienta pero nunca reemplaza a los modos de permisos ni a las protecciones de seguridad. Al terminar sabrás preparar el "cerebro de contexto" del agente para trabajo de seguridad consistente y predecible, dejando listo el terreno para construir más adelante un CLAUDE.md de seguridad completo. Ideal para analistas, pentesters y equipos de SOC que quieren resultados fiables y repetibles.

Aprender qué hacer es la mitad del trabajo; la otra mitad es saber qué NO hacer. En esta clase verás los seis errores de prompting más frecuentes en tareas de seguridad —los que producen resultados inútiles, inconsistentes o directamente peligrosos— y cómo corregir cada uno. Es el contrapunto práctico de la clase de los seis patrones.

Recorreremos los seis: (1) el prompt vago, sin alcance ni criterio de éxito, y cómo volverlo específico; (2) pedir resultados de experto sin dar rol ni contexto; (3) el "mega-prompt" que lo pide todo de una vez, cuando conviene encadenar; (4) confiar en la salida del agente sin verificarla, el error más caro en seguridad, y cómo exigir evidencia (archivo:línea, prueba de concepto) y permitir el "no lo sé"; (5) dejar que la entrada no confiable dé órdenes —el clásico riesgo de prompt injection al analizar un archivo, un log o una página web sospechosa— y cómo separar instrucciones de datos; y (6) sobrecargar el contexto con ruido, degradando la precisión, y cómo dar solo lo relevante.

Cada error se presenta con su síntoma ("así se ve cuando ocurre") y su corrección concreta ("hazlo así"). Prestaremos especial atención a los tres errores propios de seguridad —verificación, entrada no confiable y ruido de contexto—, porque son los que distinguen a un profesional que usa IA con criterio de uno que la usa a ciegas.

Al terminar sabrás detectar estos fallos en tus propios prompts y corregirlos al instante, ahorrándote tiempo y evitando decisiones basadas en respuestas equivocadas.

CLAUDE.md es el archivo que convierte a un agente genérico en tu analista de seguridad: la memoria persistente que Claude Code carga en cada sesión. En esta clase entenderás exactamente cómo funciona y qué debe contener para sacarle el máximo.

Empezaremos por lo esencial: qué es CLAUDE.md y por qué su contenido tiene alta prioridad (forma parte del system prompt del agente y se sigue con más rigor que un mensaje de chat). Verás cómo se carga: la jerarquía de memoria —enterprise, usuario y proyecto—, cómo Claude lee estos archivos subiendo por el árbol de directorios y los concatena, y cómo las instrucciones más específicas prevalecen. Aprenderás a usar los imports con la sintaxis @ruta para organizar tu memoria sin duplicar, y un matiz que muchos ignoran: importar ayuda al orden, pero no reduce el contexto que se carga.

Después nos centraremos en lo más útil: qué SÍ incluir (convenciones, comandos, decisiones de arquitectura, reglas y terminología de seguridad) y qué NO incluir (secrets, reglas que tu linter ya aplica, o información que Claude puede deducir del propio código). Y una regla de oro para seguridad: lo que nunca debe ocurrir no se pone en markdown, se fuerza con hooks y permisos, porque CLAUDE.md orienta pero no es una barrera.

Cerraremos con buenas prácticas concretas —mantenerlo conciso (bajo unas 200 líneas), específico y actualizado, y los comandos /init y /memory— y con la estructura de un CLAUDE.md pensado para operaciones de seguridad. Al terminar sabrás diseñar la memoria que hace que el agente trabaje con tu criterio en cada sesión.

Aprende a construir un CLAUDE.md que convierte a Claude Code en un analista de seguridad consistente en cada sesión. En esta clase práctica profundizas en la memoria persistente del agente: entenderás la jerarquía de archivos (memoria de usuario en tu home, memoria de proyecto compartida por git y política de la organización), cómo Claude Code recorre el árbol de carpetas y por qué la memoria más específica gana ante un conflicto. Construirás, sección por sección, un CLAUDE.md especializado para operaciones de seguridad: el rol de analista, restricciones verificables de alcance y manejo de secretos, el formato de hallazgo con CWE, OWASP y CVSS, y las convenciones de seguridad del proyecto. Aprenderás a mantenerlo por debajo de las 200 líneas para no degradar la adherencia, a dividir instrucciones largas con imports @ruta y con reglas por ruta en .claude/rules, y a inspeccionar qué está cargado con /memory y a recortar lo innecesario con /doctor. Verás también por qué CLAUDE.local.md quedó deprecado y cómo usar imports desde tu home para instrucciones personales que no van al repositorio. Al terminar tendrás una plantilla de CLAUDE.md de seguridad reutilizable y la disciplina para mantenerla afinada. Ideal para analistas de AppSec, pentesters y equipos de SOC que quieren un agente fiable y repetible.

Si CLAUDE.md es la memoria del agente, las skills son sus capacidades: paquetes de conocimiento y procedimientos reutilizables que Claude Code invoca justo cuando los necesita. En esta clase entenderás qué son, cómo se cargan y dónde viven, la base para construir tus propias capacidades de seguridad.

Verás la anatomía de una skill: una carpeta con un archivo SKILL.md que tiene dos partes —un frontmatter con el nombre y la descripción, que le dicen a Claude cuándo usarla, y un cuerpo con las instrucciones de cómo hacerlo— más scripts y archivos de apoyo opcionales. Entenderás el mecanismo que las hace eficientes, el progressive disclosure o divulgación progresiva: Claude solo carga la descripción de cada skill al inicio, y el cuerpo completo únicamente cuando la tarea encaja. Esto significa que puedes tener decenas de skills instaladas sin penalizar el contexto.

Después veremos cómo se disparan (de forma automática, cuando la descripción coincide con tu petición, o invocándolas por su nombre) y dónde viven, con su matiz de alcance: skills personales que te acompañan en todos tus proyectos, skills de proyecto que compartes con tu equipo, y su carga en la sesión bajo demanda. También las distinguiremos de CLAUDE.md y de MCP, para que tengas claro cuándo usar cada pieza.

Y como profesional de seguridad, prestarás atención a una advertencia importante: las skills pueden ejecutar código, así que instalarlas y verificarlas merece la misma precaución que instalar cualquier software. Al terminar sabrás qué son las skills y cómo funcionan, listo para construir las tuyas de análisis estático, detección de secrets y revisión de infraestructura en las clases prácticas.

Aprende a empaquetar tu metodología de análisis estático de código en una Skill reutilizable que Claude Code invoca automáticamente cada vez que revisa código en busca de bugs y vulnerabilidades. En esta clase práctica construirás tu primera Agent Skill de seguridad de principio a fin: entenderás la anatomía de una skill (una carpeta en .claude/skills/ con un archivo SKILL.md que lleva un frontmatter YAML con nombre y descripción, más las instrucciones en Markdown), y por qué la descripción es el campo más importante, ya que es el disparador que hace que el agente use la skill en el momento correcto. Escribirás el cuerpo de la skill con la metodología de análisis estático: qué clases de fallas buscar (inyección, secretos, criptografía débil, path traversal, deserialización insegura) y en qué formato reportar cada hallazgo. Aprenderás a incluir un script auxiliar dentro de la skill, cómo funciona la divulgación progresiva para no saturar el contexto, la diferencia entre que la invoque el modelo o llamarla por su nombre, y cómo el hot-reload te deja iterar sin reiniciar la sesión. Verás además cuándo conviene una skill frente a un CLAUDE.md o un servidor MCP. Al terminar tendrás una skill de análisis estático lista para reutilizar en cualquier repositorio y la base para construir las siguientes skills de seguridad del curso. Ideal para analistas de AppSec, revisores de código y equipos de seguridad.

Aprende a empaquetar la caza de secretos en una Skill reutilizable que Claude Code invoca para encontrar API keys, tokens y contraseñas expuestas en tus repositorios. En esta clase práctica construirás una Agent Skill especializada en detección de credenciales y dominarás las dos técnicas que usan las herramientas profesionales: los patrones regex que reconocen las formas conocidas de cada proveedor (el prefijo AKIA de AWS, ghp_ de GitHub, las claves de Stripe y Slack, las llaves privadas y los JWT) y el análisis de entropía, que atrapa secretos genéricos de aspecto aleatorio que ningún patrón anticipa. Aprenderás a combatir el enemigo número uno de esta tarea, los falsos positivos, distinguiendo un secreto real de un valor de ejemplo, un UUID, un hash o un dato de prueba. Escribirás el cuerpo de la skill con esta metodología y su formato de reporte, le añadirás un script auxiliar de barrido, y entenderás por qué hay que revisar también el historial de git y no solo los archivos actuales. Verás además la disciplina de respuesta ante una fuga: rotar la credencial de inmediato, eliminarla del historial y revisar los registros de acceso, porque los escáneres automáticos explotan un secreto filtrado en cuestión de minutos. Al terminar tendrás una skill de detección de secretos lista para cualquier repositorio y la base para conectarla más adelante a escáneres externos vía MCP. Ideal para analistas de AppSec, equipos de DevSecOps y respondedores de incidentes.

Aprende a empaquetar la revisión de infraestructura como código en una Skill reutilizable que Claude Code invoca para detectar malas configuraciones en tus archivos de Terraform y Kubernetes. En esta clase práctica construirás una Agent Skill especializada en seguridad de IaC y dominarás el catálogo de misconfigurations que más incidentes provoca: en Terraform, almacenamiento público o sin cifrar, security groups abiertos a todo internet en puertos sensibles, políticas IAM con permisos comodín, bases de datos accesibles públicamente y secretos escritos en los valores por defecto; en Kubernetes, contenedores que corren como root o en modo privilegiado, ausencia de límites de recursos, montajes peligrosos del host, falta de contexto de seguridad y secretos en texto plano. Escribirás el cuerpo de la skill con este catálogo y un formato de hallazgo que mapea cada problema a su control y su remediación, le añadirás un script de barrido, y aprenderás una disciplina clave: el contexto manda, de modo que una excepción legítima se documenta con su justificación en lugar de silenciarse a ciegas. Verás cómo se relaciona esta skill con escáneres profesionales como Checkov y Trivy, que más adelante podrás conectar vía MCP. Al terminar tendrás una skill de revisión de IaC lista para cualquier repositorio y habrás cerrado el bloque de skills del curso. Ideal para equipos de DevSecOps, ingenieros de plataforma y analistas de seguridad en la nube.

Hasta ahora, el agente solo alcanzaba lo que había en tu entorno. MCP es lo que le permite salir a buscar al mundo exterior: conectarse a tus herramientas de seguridad y a datos en tiempo real. En esta clase entenderás qué es el Model Context Protocol y por qué es la pieza que multiplica las capacidades de Claude Code.

Empezaremos por el problema que resuelve: un agente aislado, por muy potente que sea, está atrapado detrás de silos de información. Verás la solución que propuso Anthropic con MCP, un estándar abierto que funciona como un "USB-C para la IA": un conector universal que sustituye las integraciones fragmentadas por un solo protocolo. Entenderás el problema M×N que elimina —pasar de construir una integración a medida por cada par de modelo y herramienta a un modelo lineal, "escríbelo una vez y úsalo en todas partes"— y por qué eso ha convertido a MCP en el estándar de facto de la industria, con miles de servidores ya disponibles.

Después veremos qué expone realmente un servidor MCP: tools (acciones que el agente puede ejecutar), resources (datos que puede leer) y prompts (plantillas de trabajo), todo de forma auto-descriptiva, para que el agente pregunte "qué hay disponible" y se adapte. Y lo llevaremos a tu terreno: cómo MCP conecta al agente con Shodan, VirusTotal, AbuseIPDB, un SIEM o un escáner de vulnerabilidades, y cómo se añaden estos servidores en Claude Code.

Cerraremos con la seguridad del propio protocolo: los permisos explícitos, la autenticación y por qué conectar un servidor MCP equivale a concederle acceso al agente, algo que hay que tratar con criterio. Al terminar sabrás qué es MCP y por qué es la capa de integración que abre la puerta a un equipo de seguridad realmente conectado.

En la clase anterior vimos qué es MCP y por qué importa. Ahora abrimos el capó: cómo funciona por dentro, para que sepas exactamente qué ocurre cada vez que el agente usa una herramienta externa. Entender esta arquitectura es lo que te permite conectar, depurar y —sobre todo— asegurar tus integraciones con criterio.

Empezaremos por los tres roles del sistema: el host (la aplicación, Claude Code), el cliente (el conector que mantiene una conexión dedicada con cada servidor) y el servidor (lo que expone las capacidades). Verás que hablan entre sí con JSON-RPC, un formato de mensajes estándar, y que ese diálogo viaja por uno de dos transportes: stdio, para servidores locales que corren en tu propia máquina, o Streamable HTTP, para servidores remotos. Esa distinción no es un tecnicismo: define la frontera de confianza, porque un servidor local vive dentro del límite de tu host, mientras que uno remoto es un servicio de red que exige autenticación.

Después seguiremos el ciclo de vida completo de una interacción: la inicialización, el descubrimiento —cómo el agente averigua qué herramientas hay, leyendo su nombre, su descripción y el esquema de sus parámetros— y la invocación, el corazón de la clase: cómo Claude decide llamar a una tool, arma los argumentos, pasa por tu permiso, el servidor ejecuta y el resultado regresa a su contexto para que siga razonando. Veremos también qué hay dentro de un servidor (casi siempre, un envoltorio fino sobre una API o una base de datos real).

Cerraremos con la seguridad de esta arquitectura: los permisos explícitos, la frontera de confianza entre local y remoto, y por qué un servidor remoto hereda las exigencias de seguridad de cualquier servicio web. Al terminar entenderás el mecanismo completo, de la petición al resultado.

Aprende a darle a Claude Code su primer superpoder externo conectándolo a Shodan mediante MCP para hacer reconocimiento OSINT en tiempo real. En esta clase práctica configurarás un servidor MCP de Shodan de principio a fin y entenderás la mecánica que usarás en todas las integraciones del curso: el comando claude mcp add, la elección del transporte (stdio para servidores locales, HTTP para remotos), y los tres scopes que deciden dónde vive la configuración y si se comparte o no con tu equipo. Aprenderás a obtener tu clave de API de Shodan y a entregarla al servidor con la variable de entorno adecuada, a verificar la conexión con claude mcp list y con el comando /mcp, y a consultar Shodan en lenguaje natural para investigar una dirección IP, descubrir servicios expuestos, resolver DNS o revisar vulnerabilidades conocidas. Y como corresponde a un curso de seguridad, dominarás la disciplina que rodea a MCP: no commitear nunca tus claves y protegerlas con gitignore, fijar la versión del servidor para evitar ataques de cadena de suministro, aprovechar que Claude Code pide permiso antes de invocar cada herramienta, y hacer reconocimiento solo sobre objetivos autorizados. Al terminar tendrás Shodan integrado en tu agente y la base para conectar, en las próximas clases, VirusTotal, escáneres y tu SIEM. Ideal para analistas OSINT, pentesters y equipos de threat intelligence.

Aprende a automatizar el enriquecimiento de indicadores de compromiso conectando Claude Code a VirusTotal y AbuseIPDB mediante MCP. En esta clase práctica montarás dos servidores MCP reutilizando la mecánica que ya dominas —el comando claude mcp add, el transporte stdio, la entrega de la clave por variable de entorno y la buena práctica de fijar una versión que exista consultándola con npm view— y le darás al agente la capacidad de puntuar la reputación de cualquier indicador. Con VirusTotal, el agente analizará URLs, hashes de archivos, dominios e IPs contra más de setenta motores de seguridad; con AbuseIPDB, obtendrá el nivel de confianza de abuso de una dirección IP a partir de los reportes de la comunidad. Aprenderás a encadenar esto con la extracción de IOCs que viste antes, para pasar de una lista de indicadores en bruto a un veredicto enriquecido y accionable, y verás por qué combinar varias fuentes es más fiable que confiar en una sola, ya que unas pocas detecciones no siempre significan malicioso y un puntaje comunitario es una señal, no una sentencia. Cubriremos también los límites de los planes gratuitos, que aquí sí funcionan, y la disciplina de espaciar las consultas para no agotar la cuota. Al terminar tendrás un flujo de enriquecimiento de IOCs automatizado dentro del agente, listo para tu trabajo de threat intelligence y respuesta a incidentes. Ideal para analistas de SOC, threat hunters y respondedores de incidentes.

Aprende a darle a Claude Code un motor SAST de verdad conectándolo al servidor MCP oficial de Semgrep, para que el agente ejecute análisis de seguridad deterministas sobre tu código en lugar de solo leerlo. En esta clase práctica montarás el escáner reutilizando la mecánica que ya dominas —esta vez con uvx, igual que hiciste con AbuseIPDB— y descubrirás una ventaja enorme: el servidor de Semgrep no necesita clave de API, porque el motor corre localmente y tu código nunca sale de tu máquina. Verás cómo el agente invoca las herramientas de escaneo para encontrar vulnerabilidades con la extensa librería de reglas de Semgrep, y entenderás la diferencia profunda frente a la skill de análisis estático que construiste antes: el escáner aporta hallazgos deterministas y rápidos, y el agente aporta el triaje, el contexto y la priorización, que es justo donde se reducen los falsos positivos. Aprenderás además un punto crucial de comportamiento: conectar el escáner lo pone a disposición, pero el agente lo usa cuando lo decide, así que te enseñaré a instruirlo desde tu CLAUDE.md para que escanee siempre que corresponda. Cubriremos también cómo cubrir Python con Bandit y cómo interpretar los resultados sin ahogarte en ruido, porque la explotabilidad depende del contexto. Al terminar tendrás un escáner de vulnerabilidades integrado en tu agente, cerrando el puente entre tus skills y las herramientas profesionales. Ideal para equipos de AppSec, DevSecOps y revisores de código.

Un agente es probabilístico: hace las cosas casi siempre, pero "casi" no basta en seguridad. Los hooks son la pieza que convierte ese "casi siempre" en un "siempre". En esta clase entenderás qué son y por qué son la única capa que de verdad garantiza el comportamiento del agente.

Partiremos del problema: CLAUDE.md y las skills guían al agente, pero no lo obligan; dependen de que el modelo decida seguirlas. Los hooks resuelven eso con control determinista: son handlers que Claude Code ejecuta automáticamente en puntos fijos de su ciclo de vida, funcionan como los git hooks pero para tu agente de IA, y se ejecutan siempre, sin depender de que el modelo se acuerde.

Recorreremos los cuatro eventos clave: PreToolUse, que se dispara antes de usar una herramienta y puede bloquearla; PostToolUse, que se dispara después y sirve para reaccionar (formatear, registrar, auditar), aunque no puede deshacer lo hecho; Stop, cuando el agente termina su respuesta; y Notification, para enviar alertas. Verás la distinción más importante en la práctica —prevención con PreToolUse frente a reacción con PostToolUse—, cómo se configuran en el archivo settings.json (evento, matcher y handler) y cómo decide un hook: deja pasar o bloquea, con una propiedad de seguridad esencial: los hooks solo restringen permisos, nunca los relajan.

Aprende a poner una capa de control determinista por debajo del agente construyendo tu primer hook PreToolUse en Claude Code, un guardián que intercepta cada acción antes de ejecutarse y decide si la permite o la bloquea. En esta clase práctica entenderás por qué los hooks son la pieza que da garantías en un sistema que, por naturaleza, es probabilístico: mientras el modelo puede olvidarse de una regla, un hook se ejecuta siempre. Configurarás el hook en el archivo settings.json de tu proyecto, aprenderás a usar el matcher para aplicarlo solo a las herramientas que te interesan, y verás cómo el hook recibe por la entrada estándar un JSON con el nombre de la herramienta y sus argumentos, como el comando que el agente quiere correr. Dominarás las dos formas de responder desde el hook, el código de salida (donde salir con dos bloquea la acción y devuelve el motivo al agente) y la salida en JSON con una decisión de permiso explícita y su razón. Construirás un guardián real que detiene un comando destructivo antes de que llegue a la terminal, y comprenderás el principio de seguridad más importante de los hooks, que se disparan antes que los permisos y solo pueden endurecer la política, nunca debilitarla, de modo que protegen al agente incluso en los modos más permisivos. Esta es la base sobre la que montarás, en el resto de la sección, la auditoría, el bloqueo de secretos y los pipelines de gates encadenados. Ideal para equipos de seguridad, DevSecOps y cualquiera que quiera gobernar a un agente con garantías reales.

Aprende a darle memoria forense a tu agente construyendo un hook PostToolUse en Claude Code que registra cada acción que ejecuta, creando un rastro de auditoría fiable. En esta clase práctica entenderás la diferencia esencial con el hook de la clase anterior: mientras el PreToolUse es un guardián que se dispara antes y puede bloquear, el PostToolUse es un observador que se dispara después y no puede impedir la acción, pero sí dejar constancia de ella. Verás que su entrada trae algo que el anterior no tenía, el resultado de la herramienta, así que no solo registras qué intentó hacer el agente, sino qué ocurrió. Configurarás el hook en el settings.json apuntando al evento posterior, y escribirás un script que lee el JSON de la entrada estándar, extrae la herramienta usada, el comando o el archivo afectado y la marca de tiempo, y los añade como una nueva línea a un registro de auditoría. Comprenderás por qué un rastro append-only es oro para la seguridad, ya que responde al quién, qué y cuándo cuando investigas un incidente o necesitas demostrar cumplimiento, y aprenderás a comprobar el hook alimentándole datos a mano y viendo crecer tu log. Cerraremos con la disciplina correcta, registrar sobre todo las acciones que modifican cosas, mantener el hook veloz para no frenar al agente, y tratar los datos de entrada como no confiables. Con esto sumas la capa de observabilidad a tu arsenal de gates, camino de los controles más avanzados de la sección. Ideal para equipos de seguridad, DevSecOps y responsables de cumplimiento.

Aprende a impedir que un secreto llegue nunca al disco construyendo un hook PreToolUse en Claude Code que inspecciona lo que el agente va a escribir y lo bloquea si contiene una credencial. En esta clase práctica unirás dos cosas que ya sabes, la mecánica de hooks y la detección de secretos, para pasar de detectar a prevenir. Configurarás el hook en el settings.json con un matcher para las herramientas de escritura y edición, y escribirás un script que lee de la entrada estándar el contenido que el agente pretende guardar, ya sea el texto completo de un archivo nuevo o el fragmento nuevo de una edición, y lo compara contra patrones de alta confianza como las claves de AWS, los tokens de GitHub, las llaves de API, las claves privadas y los JWT. Cuando encuentra uno, el hook sale con el código que bloquea la acción y le devuelve al agente un mensaje claro de qué pasó y cómo corregirlo, por ejemplo moviendo el secreto a una variable de entorno. Entenderás la diferencia profunda con la skill de detección que construiste antes, porque una skill detecta lo que ya existe y el agente podría no invocarla, mientras que este hook es una barrera determinista que se ejecuta en cada escritura sin excepción. Es la mejor ilustración del principio de la sección, que las reglas del CLAUDE.md son sugerencias y los hooks son cumplimiento. Aprenderás a comprobarlo alimentándole contenido a mano y a ampliar la cobertura para cerrar también la puerta de la terminal. Ideal para equipos de seguridad, DevSecOps y cualquiera que trabaje con credenciales.

En la clase anterior conociste a los subagentes de uno en uno. Ahora los ponemos a trabajar a la vez: aquí es donde un equipo de seguridad con IA despliega todo su poder. Aprenderás el patrón que lo hace posible y cómo aplicarlo sin caer en sus trampas.

El patrón se llama fan-out, reduce y synthesize —repartir, recoger y sintetizar—, también conocido como split-and-merge. Verás cómo funciona la estructura de dos niveles: un orquestador, que es tu instancia principal de Claude, descompone una tarea grande, reparte los trozos entre varios subagentes que trabajan en paralelo, y luego recoge y sintetiza sus resultados en uno solo. Es la misma lógica del map-reduce, pero aplicada a agentes que razonan.

Entenderás la precondición imprescindible —la independencia: el paralelismo solo funciona si las subtareas no dependen unas de otras, justo lo contrario del trabajo secuencial que vimos que conviene evitar—, y la diferencia entre subagentes en primer plano (que bloquean y te pasan los permisos) y en segundo plano (que corren mientras sigues trabajando). Aprenderás un detalle práctico que casi nadie conoce: Claude es conservador con el paralelismo por defecto, así que si quieres un fan-out real tienes que pedirlo de forma explícita y concreta. Y verás su coste: cada resumen vuelve al contexto principal y los tokens escalan con el número de agentes.

Cerraremos poniendo a tu equipo de seguridad —analizador de código, escáner de vulnerabilidades, detector de secrets y revisor de configuración— a trabajar todos a la vez sobre un mismo codebase, produciendo un informe unificado, y repasaremos patrones de calidad como la verificación adversarial y los errores más comunes. Al terminar sabrás orquestar subagentes en paralelo con criterio.

Aprende a delegar el análisis de seguridad a un especialista construyendo tu primer subagente en Claude Code, un agente enfocado exclusivamente en leer y clasificar vulnerabilidades en código fuente. En esta clase práctica entenderás qué distingue a un subagente de todo lo que ya conoces, porque no es una instrucción que se suma a tu conversación, sino una instancia separada de Claude, con su propio contexto, su propio prompt y sus propias herramientas, a la que el agente principal le encarga un trabajo y de la que recibe de vuelta solo el resultado. Esa separación es su superpoder, ya que el subagente puede revisar decenas de archivos sin llenar de ruido la sesión principal. Lo definirás como un archivo Markdown en la carpeta de agentes, con un frontmatter donde el nombre lo identifica, la descripción decide cuándo se activa, y la lista de herramientas lo limita a solo lectura, porque un analizador lee y reporta, pero no modifica. En el cuerpo escribirás su prompt de sistema, dándole el rol de analista de seguridad de aplicaciones, la lista de fallas que debe buscar y el formato con el que clasifica cada hallazgo por su CWE, su categoría OWASP y su severidad. Verás cómo se invoca, tanto de forma automática como pidiéndolo por su nombre, y entenderás la diferencia profunda con la skill de análisis estático que ya construiste. Al terminar tendrás tu primer miembro del equipo de seguridad con IA, la base sobre la que en las próximas clases sumarás más especialistas. Ideal para equipos de AppSec, revisores de código y analistas de seguridad.

Aprende a poner un motor de análisis real en manos de un especialista construyendo un subagente escáner de vulnerabilidades en Claude Code, un agente que invoca una herramienta de escaneo y convierte su salida cruda en un reporte útil. En esta clase práctica verás la diferencia clave con el subagente analizador de la clase anterior, porque aquel leía el código con su propio criterio, mientras que este ejecuta un escáner determinista, como Bandit para Python o Semgrep para varios lenguajes, y luego procesa e interpreta lo que el motor le devuelve. Definirás el subagente en su archivo de la carpeta de agentes, con un frontmatter donde las herramientas se limitan a lo justo, en este caso la capacidad de ejecutar el escáner y de leer archivos, y en el cuerpo escribirás su prompt de sistema, que le indica correr el escaneo, leer la salida en formato estructurado, agrupar hallazgos repetidos, priorizarlos por severidad y marcar los probables falsos positivos, entregando al final un informe claro. Entenderás por qué el reparto de trabajo entre el motor, que encuentra, y el agente, que tría, es lo que convierte una lista abrumadora en algo accionable. Cubriremos también la nota de mínimo privilegio propia de este agente, que a diferencia del analizador sí necesita ejecutar, así que conviene acotarlo bien y respaldarlo con tus hooks. Al terminar tendrás el segundo miembro de tu equipo de seguridad con IA, en camino de orquestarlos a todos. Ideal para equipos de AppSec, DevSecOps y revisores de código.

Aprende a sumar a tu equipo de seguridad un cazador de credenciales construyendo un subagente detector de secretos en Claude Code, especializado en encontrar claves, tokens y contraseñas expuestas en tu repositorio. En esta clase práctica reutilizarás la metodología de detección de secretos que ya conoces, ahora encarnada en un especialista con su propio contexto, al que el agente principal delega esta tarea concreta. Definirás el subagente en su archivo de la carpeta de agentes, con herramientas de solo lectura, porque igual que el analizador, este detecta y reporta pero no toca nada. En su prompt de sistema le darás las dos técnicas que se complementan, buscar las formas conocidas de credencial por sus prefijos característicos, como los de AWS, GitHub, Stripe o Slack, y detectar cadenas de alta entropía que no encajan en ningún patrón pero parecen secretos genéricos. Le enseñarás también a descartar los falsos positivos, esos valores de ejemplo, identificadores y hashes que no son credenciales, para que su informe sea creíble y no ruido. Y le darás la disciplina de respuesta correcta, tratar todo secreto expuesto como comprometido y recomendar rotarlo de inmediato. Verás la diferencia con la skill de secretos que hiciste antes, porque ahora es un especialista aislado que devuelve solo su informe, y aprenderás cómo darle opcionalmente una herramienta real como gitleaks para escaneos más profundos. Al terminar tendrás el tercer miembro de tu equipo, en camino de orquestarlos a todos. Ideal para equipos de AppSec, DevSecOps y respuesta a incidentes.

Completa tu equipo de seguridad con un auditor de infraestructura construyendo un subagente revisor de IaC en Claude Code, especializado en encontrar malas configuraciones en archivos de Terraform, Docker y Kubernetes. En esta clase práctica reunirás en un solo especialista el criterio para auditar las tres tecnologías que sostienen la infraestructura moderna. Lo definirás en su archivo de la carpeta de agentes, con herramientas de solo lectura, porque como tus otros revisores, este detecta y reporta pero no modifica. En su prompt de sistema le darás tres catálogos de fallas. Para Terraform, almacenamiento público o sin cifrar, accesos abiertos a todo internet en puertos sensibles, permisos IAM con comodín y bases de datos expuestas. Para Kubernetes, contenedores privilegiados o como root, ausencia de límites de recursos, montajes peligrosos del host e imágenes con tag latest. Y para Docker, el nuevo foco de la clase, contenedores que corren como root, imágenes base sin fijar, secretos escritos en el Dockerfile, el peligroso montaje del socket de Docker y los privilegios excesivos. Le enseñarás además la disciplina profesional de que el contexto manda, de modo que una configuración que parece insegura puede ser una excepción legítima que se documenta en vez de alarmar. Verás cómo se relaciona con escáneres reales como hadolint y Trivy, que podrías darle como herramienta, y entenderás cómo este cuarto especialista completa el equipo antes de orquestarlos a todos. Ideal para equipos de DevSecOps, ingeniería de plataforma y seguridad en la nube.

Llega el gran final de la sección: unir a tus cuatro especialistas en un sistema completo de auditoría de seguridad construyendo el orquestador que los coordina a la vez. En esta clase práctica aprenderás el patrón que está transformando el trabajo con agentes, dividir, repartir en paralelo y consolidar. Tu agente principal, actuando como orquestador, lanzará simultáneamente al analizador de código, al escáner de vulnerabilidades, al detector de secretos y al revisor de infraestructura, cada uno trabajando aislado en su propio contexto, y luego reunirá sus informes en un único reporte de seguridad priorizado. Entenderás por qué correr los cuatro en paralelo es tan potente, ya que el tiempo total pasa a ser el del especialista más lento y no la suma de todos, y por qué cada uno mantiene limpia la conversación principal. Aprenderás una regla de arquitectura fundamental, que los subagentes no pueden llamar a otros subagentes, de modo que el orquestador tiene que ser tu hilo principal, y descubrirás que Claude por defecto trabaja en serie, así que tendrás que darle instrucciones explícitas para que despache a todos a la vez. Empaquetarás esa orquestación como un comando reutilizable, para lanzar una auditoría completa con una sola orden, y verás cómo el orquestador reconcilia hallazgos, elimina duplicados y prioriza, dejándote a ti, el humano, la decisión final. Al terminar tendrás un sistema multi-agente de auditoría de seguridad de principio a fin, la culminación de todo lo que construiste en la sección. Ideal para equipos de seguridad, DevSecOps y líderes técnicos.

Aprende a hacer revisiones de seguridad como un profesional aplicando con Claude Code el flujo de cinco pasos que usan los equipos de AppSec, en lugar de lanzar un prompt genérico que devuelve consejos vagos. En esta clase práctica descubrirás por qué pedirle a un agente que "revise la seguridad" sin más produce resultados pobres, y cómo descomponer la revisión en un método estructurado la transforma en un análisis serio, con referencias a archivo y línea. Recorrerás los cinco pasos uno a uno. Primero, el descubrimiento de arquitectura, donde el agente mapea el proyecto, sus lenguajes, marcos de trabajo y puntos de entrada. Segundo, el mapeo de la superficie de ataque, identificando por dónde entra la entrada no confiable, que es lo que un atacante puede alcanzar. Tercero, el escaneo, poniendo a trabajar tus subagentes y motores de análisis sobre esa superficie. Cuarto, la clasificación, ordenando cada hallazgo por su CWE, su categoría OWASP y su severidad, y separando lo explotable de los falsos positivos. Y quinto, el reporte, consolidando todo en un informe con resumen ejecutivo, hallazgos priorizados y remediación. Verás cómo este flujo reutiliza todo lo que construiste en el curso, las skills, los subagentes y el orquestador, y cómo empaquetarlo en un comando para repetir la revisión cuando quieras. Al terminar tendrás una metodología de revisión de seguridad completa y repetible, con el criterio para dirigirla y la última palabra siempre en tus manos. Ideal para equipos de AppSec, revisores de código y consultores de seguridad.

Aprende a triar correos de phishing y artefactos de malware de forma segura y defensiva con Claude Code, siguiendo el proceso que usan los analistas de un SOC. En esta clase práctica verás cómo el agente te ayuda a diseccionar un correo sospechoso sin correr ningún riesgo, porque todo el análisis es estático y nunca se ejecuta ni se abre nada. Empezarás por la regla de seguridad que gobierna todo, manejar la muestra en aislamiento y no clicar jamás. Luego aprenderás a leer la cabecera del correo con el agente, siguiendo la cadena de servidores de abajo hacia arriba para encontrar la IP real de origen, detectando las discrepancias entre el remitente visible y el real, e interpretando los resultados de autenticación SPF, DKIM y DMARC que el servidor ya calculó. Pasarás a triar las URLs y los adjuntos en aislamiento, defangeando cada indicador para compartirlo sin peligro, y para los archivos adjuntos calcularás su hash y lo enriquecerás en VirusTotal sin abrirlo nunca. Verás cómo mapear los hallazgos al marco MITRE ATT&CK y cerrar con un veredicto claro. Para el malware, entenderás el triaje puramente estático, hashes, entropía y cadenas, sin detonar jamás la muestra fuera de un sandbox. Y comprobarás cómo esta clase reutiliza la extracción de IOCs y el enriquecimiento que ya construiste. Al terminar tendrás un flujo de triaje de phishing y malware seguro y repetible, con el veredicto siempre en tus manos. Ideal para analistas de SOC, respuesta a incidentes y blue teams.

Aprende a convertir tus hallazgos de un análisis en reglas de detección que cazan la amenaza automáticamente, generando reglas YARA y SIGMA con Claude Code. En esta clase práctica cerrarás el ciclo que abriste al triar phishing y malware, porque de nada sirve detectar una amenaza una vez si no la conviertes en una regla que la detecte para siempre. Entenderás la diferencia esencial entre las dos, ya que YARA busca patrones en archivos y memoria, ideal para cazar malware en los endpoints, mientras que SIGMA describe comportamientos en los registros de eventos y es neutral respecto al SIEM, así que una misma regla sirve para Splunk, Elastic o cualquier otro. Verás cómo pedirle al agente que genere ambas a partir de tus indicadores, la estructura de una regla YARA con sus metadatos, sus cadenas y su condición, y la de una regla SIGMA en YAML con su fuente de registros, su lógica de detección, sus falsos positivos y su mapeo a MITRE ATT&CK. Pero la lección profesional va más allá de generar, porque el agente redacta la regla en segundos y el trabajo de verdad es afinarla. Aprenderás por qué una regla basada en una cadena genérica o en un solo hash es una mala regla que genera ruido o envejece enseguida, y cómo dirigir al agente hacia reglas fuertes, que combinan varias señales, definen sus falsos positivos y se pueden probar antes de desplegar. Al terminar sabrás producir detección accionable y mantenible, no solo firmas sueltas. Ideal para ingenieros de detección, analistas de SOC y threat hunters.

Aprende a convertir a Claude Code en el copiloto de tu reconocimiento, usándolo para analizar la salida de las herramientas clásicas de un pentest y sacar conclusiones accionables en segundos. En esta clase práctica descubrirás el papel que de verdad juega la IA en esta fase, porque el agente no escanea nada por su cuenta, sino que se sienta encima de tu cadena de herramientas como una capa de análisis que interpreta lo que ellas producen. Verás cómo cada herramienta cubre su fase del trabajo, ya que Nmap descubre los hosts vivos, los puertos abiertos y las versiones de los servicios, Nessus enumera las vulnerabilidades conocidas a gran escala, y Burp Suite te deja diseccionar las aplicaciones web. Y aprenderás a darle esa salida al agente para que haga lo que mejor sabe hacer, que es cortar el ruido de miles de líneas, señalar los servicios con vulnerabilidades recientes, detectar las combinaciones extrañas de puerto y servicio que sugieren una aplicación a medida, y priorizar dónde vale la pena mirar primero. Antes de nada dominarás la regla que gobierna toda esta fase, porque el reconocimiento y el escaneo solo se realizan sobre sistemas propios o con autorización explícita y un alcance escrito, ya que hacerlo fuera de eso deja de ser un pentest para convertirse en un delito. Al terminar sabrás usar al agente como un multiplicador de tu criterio en la fase de reconocimiento, sin que sustituya jamás tu juicio profesional. Ideal para pentesters, red teams y estudiantes de hacking ético.

Aprende a construir el perfil de un actor de amenaza con Claude Code, transformando datos de inteligencia dispersos en un análisis estructurado y con niveles de confianza. En esta clase práctica descubrirás cómo el agente te ayuda a leer montañas de inteligencia de amenazas y a extraer de ellas lo que de verdad caracteriza a un adversario, que son sus tácticas, técnicas y procedimientos. Aprenderás a mapear esos comportamientos al marco MITRE ATT&CK, donde las tácticas describen el porqué de cada movimiento y las técnicas el cómo, y a organizar tus hallazgos con el Diamond Model alrededor de sus cuatro vértices, el adversario, su capacidad, su infraestructura y su víctima. Verás por qué el perfilado basado en el comportamiento es mucho más sólido que perseguir indicadores sueltos, ya que un atacante cambia sus dominios y sus hashes en minutos pero rara vez cambia su forma de operar. Y sobre todo interiorizarás la disciplina que define a un buen analista de inteligencia, que es entender que la atribución es siempre una probabilidad y no una certeza, de modo que tus conclusiones se expresan como hipótesis con un nivel de confianza asignado y jamás como acusaciones sin pruebas. Aprenderás también a mantener el rigor frente al agente, verificando cada técnica que proponga, porque un modelo puede sugerir comportamientos que en realidad no ocurrieron. Al terminar sabrás producir perfiles de actor accionables y responsables, con el criterio siempre en tus manos. Ideal para analistas de CTI, equipos de SOC y threat hunters.

Durante todo el curso hemos dado poder al agente: memoria, herramientas, conexiones MCP, subagentes, autonomía. En esta sección damos la vuelta a la moneda y preguntamos: ¿qué de todo ese poder se puede volver en tu contra? Esta clase es el mapa de los peligros, el modelo de amenaza que necesitas antes de entrar en los ataques concretos.

Entenderás el cambio de fondo que lo transforma todo: un chatbot solo respondía; un agente actúa —envía correos, consulta bases de datos, llama a APIs, toma decisiones—, y ese salto de pasivo a activo convierte su propio poder en superficie de ataque. Verás los cuatro motores que expanden esa superficie —la autonomía, la memoria persistente, el acceso a herramientas y la coordinación entre agentes—, que reconocerás porque son, exactamente, las piezas que aprendiste a construir. Y comprenderás el modelo de "brecha progresiva": en un agente, una instrucción envenenada ya no es solo texto inseguro, se convierte en una llamada a una API; una entrada de memoria manipulada deja de ser un sesgo y pasa a ser una decisión de flujo; una alucinación puede terminar siendo código ejecutado.

Recorreremos el mapa de amenazas agénticas —secuestro de objetivos, uso indebido de herramientas, abuso de identidad y privilegios, envenenamiento de memoria, riesgos de cadena de suministro y explotación de la confianza del operador— y el pecado capital que las habilita: la agencia excesiva (funcionalidad, permisos y autonomía de más). Pero no te dejaremos con miedo: cerraremos con la mentalidad defensiva y los controles que ya conoces —permisos, hooks, mínimo privilegio, aislamiento—, y con los marcos que te guían: OWASP Agentic Top 10, MITRE ATLAS y NIST.

Al terminar tendrás el modelo de amenaza completo, listo para atacar cada riesgo en las clases que siguen.

Es el riesgo número uno en seguridad de LLMs desde que existen las listas de OWASP, y en un agente es aún más peligroso. En esta clase entenderás, desde la óptica del defensor, qué son el prompt injection y el jailbreaking, por qué funcionan y —lo más importante— cómo detectarlos y mitigarlos. No veremos payloads ni recetas de ataque: veremos el modelo de amenaza y las defensas.

Empezaremos distinguiendo los dos conceptos: el prompt injection es el paraguas —cuando una entrada altera el comportamiento del agente de forma no intencionada— y el jailbreaking es el subconjunto que busca anular por completo las salvaguardas del modelo. Entenderás la causa raíz que lo hace tan difícil de resolver: a diferencia de un sistema tradicional, el agente procesa las instrucciones y los datos en el mismo contexto, sin una separación clara entre el plano de control y el de datos. Verás la distinción clave entre inyección directa (el atacante escribe el ataque) e indirecta (el ataque viene escondido en un PDF, una web, un correo o un log que el agente ingiere), y por qué la indirecta es la gran amenaza para los agentes, que constantemente leen contenido externo.

Un punto crucial: el prompt injection no es SQL injection. No existe un "escape" que lo elimine del todo, así que la defensa es en profundidad, por capas. Recorreremos cómo detectarlo —frases sospechosas, ofuscación, instrucciones incrustadas en los datos— y cómo mitigarlo con los controles que ya conoces: separar instrucciones de datos, mínimo privilegio, verificación humana, validación de salidas y red-teaming. Cerraremos con una dosis de realismo: ningún modelo es inmune y los filtros son evadibles, por lo que la defensa por capas es la única respuesta seria.

Al terminar sabrás reconocer y frenar estos ataques con criterio profesional.

Cerramos el curso con el ataque que vive en el mismo corazón de lo que construimos: las herramientas conectadas por MCP. En la clase anterior viste el prompt injection; esta es su versión especializada y, en muchos sentidos, más peligrosa, porque ataca la capa en la que el agente más confía. Enfoque defensivo, sin payloads.

Entenderás la idea central: el MCP poisoning es inyección indirecta, pero llevada a la capa de las herramientas. En lugar de esconder instrucciones en un documento, el atacante las esconde en la metadata de una tool —su descripción, su schema de parámetros o incluso sus valores de retorno—, y el agente las trata como autoritativas porque asume que vienen del sistema, no de un usuario. Ese es el matiz que lo hace tan grave: no es texto que tus filtros escaneen, es un ataque de cadena de suministro sobre el contexto del agente. Su causa raíz es que los agentes confían en herramientas que no pueden verificar.

Recorreremos el catálogo de variantes que debes conocer: el tool poisoning en la descripción, el temido rug pull (un servidor benigno que, tras ser aprobado, cambia sus definiciones para volverse malicioso), el tool shadowing (una tool que manipula el comportamiento del agente hacia tools de otros servidores de confianza) y el envenenamiento del schema y de los retornos. Verás que no es teórico: hay CVEs reales asignados. Y, sobre todo, aprenderás a defenderte: detectar comportamiento anómalo y cambios en las definiciones, y mitigar en profundidad con servidores de confianza, fijación de definiciones con alertas, schemas estrictos, aislamiento, mínimo privilegio y verificación humana.

Al terminar tendrás el modelo de amenaza completo del ecosistema MCP, y con él, cerrado el círculo de la seguridad del agente.

Aprende a encerrar al agente dentro de límites estrictos configurando permisos granulares en Claude Code, para que solo pueda hacer exactamente lo que necesita y nada más. En esta clase práctica, la primera de la sección dedicada a proteger al propio agente, aplicarás el principio de mínimo privilegio de forma concreta. Entenderás el sistema de permisos, con sus tres tipos de regla, las que permiten una acción sin preguntar, las que la bloquean por completo, y las que fuerzan una confirmación, y aprenderás la regla de oro de que la denegación siempre gana sobre el permiso. Configurarás ese sistema en el archivo settings.json escribiendo reglas precisas para cada herramienta, de modo que el agente pueda correr tus comandos de confianza sin molestarte pero tenga prohibido tocar lo peligroso. Verás la estrategia profesional de empezar con una lista de denegación fuerte y abrir permisos solo cuando ganes confianza, dejando que el comportamiento de preguntar por defecto atrape todo lo demás. Y comprenderás un hallazgo revelador, que preguntar por cada acción crea una falsa sensación de control porque la gente aprueba casi todo sin mirar, de manera que la verdadera seguridad nace de decidir por adelantado y no en el momento. Aprenderás también dónde viven estas reglas según su alcance y por qué jamás debes saltarte los permisos en un entorno con credenciales. Al terminar sabrás limitar el radio de acción del agente con precisión quirúrgica. Ideal para equipos de seguridad, DevSecOps y cualquiera que ejecute agentes con acceso real.

Aprende a encerrar al agente en una caja de arena para que, pase lo que pase, no pueda tocar tu sistema de producción, sumando la capa de defensa más profunda de todas. En esta clase práctica trabajarás el aislamiento a nivel del sistema operativo, que es lo que de verdad contiene a un agente comprometido. Descubrirás el sandbox nativo de Claude Code, que en Linux se apoya en bubblewrap para aislar el sistema de archivos y en socat para filtrar la red, y que envuelve la ejecución de comandos de modo que el agente solo puede escribir en su directorio de trabajo y solo puede alcanzar los dominios que autorices. Entenderás por qué esta capa es imprescindible incluso teniendo permisos, y aquí está la lección clave de la clase, porque una regla de permisos que bloquea la herramienta de lectura no impide que el agente lea el mismo archivo con un comando de terminal, mientras que el sandbox lo bloquea a un nivel más bajo que ningún comando puede esquivar. Aprenderás a instalarlo, a activarlo, a configurar qué carpetas y qué dominios quedan permitidos, y a comprobar que de verdad contiene al agente. Y verás el segundo nivel de aislamiento, que consiste en ejecutar todo Claude Code dentro de un contenedor Docker, de manera que solo exista para él lo que tú montes y el radio de daño quede limitado por el contenedor. Al terminar comprenderás cómo se apilan permisos, hooks y sandbox en una verdadera defensa en profundidad. Ideal para equipos de seguridad, DevSecOps y cualquiera que ejecute agentes con acceso real.