Curso de Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions

Revisión profunda de los scopes managed, user, project y local y de cómo afectan a settings, políticas y colaboración.

Diseño de una estrategia de configuración donde lo global no invada lo específico y lo local no rompa lo compartido.

Construcción de convenciones para `.claude/settings.json`, `.claude/settings.local.json`, `~/.claude/` y otros elementos persistentes del entorno.

Separación entre preferencias personales, estándares de equipo, requisitos de cumplimiento y pruebas individuales.

Revisión del valor del scope de proyecto para hooks, permisos y MCP compartidos entre colaboradores.

Detección de errores de arquitectura cuando el equipo mezcla configuración de usuario con configuración que debería viajar en git.

Preparación de un modelo de versionado y revisión de cambios sobre la configuración avanzada de Claude Code.

Construcción de una política de overrides segura para experimentación local sin contaminar al resto del equipo.

Relación entre configuración bien estructurada y menor fricción al incorporar nuevos desarrolladores al proyecto.

Taller de diseño de arquitectura `.claude` para un monorepo y para un repo de servicio.

Revisión del papel de `CLAUDE.md` como contrato de trabajo del agente y no como documento decorativo.

Construcción de un `CLAUDE.md` orientado a arquitectura, comandos, criterios de revisión, convenciones y límites operativos.

Diferenciación entre contexto estable que debe vivir en `CLAUDE.md` y contexto táctico que conviene inyectar de otra forma.

Preparación de archivos de memoria y contexto que reduzcan exploración inútil sin sobrecargar la ventana de contexto.

Detección de documentos demasiado largos o demasiado vagos que degradan la utilidad de Claude Code.

Revisión de cómo usar `CLAUDE.md` para guiar también GitHub Actions y agentes derivados.

Construcción de secciones específicas para testing, revisión de seguridad, despliegue, convenciones de commits y manejo de worktrees.

Relación entre calidad del contexto persistente y coste operativo de cada sesión o automatización.

Preparación de una estrategia de actualización progresiva de memoria a medida que evoluciona el repositorio.

Taller de rediseño de un `CLAUDE.md` para un equipo senior.

Comprensión del valor de MCP cuando el equipo deja de copiar información al chat y conecta herramientas de verdad.

Identificación de escenarios donde MCP aporta ventaja clara: issues, observabilidad, diseño, documentación, bases de datos y tooling interno.

Detección de integraciones que parecen atractivas pero introducen más ruido o riesgo que valor práctico.

Construcción de criterios para decidir cuándo un servidor MCP debe ser remoto, local o directamente descartado.

Relación entre calidad de la herramienta conectada y calidad de la decisión o implementación posterior de Claude.

Preparación de un marco de evaluación para MCP basado en utilidad, seguridad, mantenimiento y frecuencia de uso.

Revisión de cómo MCP cambia la forma de planificar tareas complejas frente al enfoque puramente textual.

Separación entre MCP para consulta, MCP para acción y MCP para eventos o canales.

Preparación de una cartera priorizada de servidores MCP según el stack real del equipo.

Taller de mapa de integraciones MCP por rol de ingeniería.

Revisión del hecho de que HTTP es hoy la opción recomendada para servidores MCP remotos.

Construcción de criterios para autenticar por cabecera, token o variables de entorno sin ensuciar la configuración del equipo.

Preparación de naming, aislamiento y documentación de servidores remotos para evitar sprawl de conectores.

Detección de riesgos de acoplamiento excesivo a servicios cloud externos dentro del flujo de desarrollo.

Análisis de cómo diseñar MCP remotos para Jira, GitHub, Sentry, Figma, Slack o servicios internos.

Revisión del comportamiento de reconexión automática de servidores HTTP y sus implicaciones sobre robustez.

Construcción de una estrategia de fallback cuando un servidor remoto falla o devuelve herramientas inestables.

Preparación de entornos de prueba seguros antes de habilitar un MCP en proyectos críticos.

Relación entre latencia del servidor MCP y calidad del trabajo iterativo con Claude Code.

Taller de diseño y conexión de varios servidores HTTP con naming y autenticación correctos.

Uso de servidores stdio para exponer herramientas internas, scripts de proyecto y automatizaciones locales.

Preparación de servidores MCP ligados al repositorio para tareas de scaffolding, calidad, observabilidad o generación de artefactos.

Revisión de cómo encapsular lógica repetitiva del equipo en utilidades consumibles por Claude Code.

Detección de casos donde stdio aporta más control y menos dependencia de infraestructura remota.

Construcción de una estructura de scripts y wrappers que haga mantenible el uso de stdio a medio plazo.

Relación entre herramienta local bien diseñada y menor necesidad de prompting complejo.

Preparación de variables de entorno, flags y contratos de entrada/salida para servidores internos.

Revisión del orden correcto de flags y del separador `--` para evitar errores de CLI al registrar servidores.

Detección de anti-patrones como usar MCP local para lo que debería ser un simple hook o comando de proyecto.

Taller de creación de un servidor MCP stdio para una utilidad interna del equipo.

Uso de `claude mcp add`, `list`, `get`, `remove` y `/mcp` como base operativa de gestión del ecosistema MCP.

Revisión de scopes de instalación de MCP y de su encaje con la arquitectura de usuario, proyecto y organización.

Construcción de una política de allowlists y denylists para equipos que necesitan gobierno fuerte sobre integraciones.

Preparación de un marco para aprobar automáticamente MCP de proyecto o exigir validación manual por servidor.

Detección de integraciones que conviene bloquear globalmente por riesgo o por irrelevancia técnica.

Relación entre gobernanza MCP y capacidad del equipo para trabajar sin deriva de tooling.

Revisión de `list_changed` y refresco dinámico de herramientas como parte del comportamiento moderno de servidores MCP.

Preparación de un proceso de alta, validación y retirada de servidores con trazabilidad mínima.

Construcción de documentación interna para que el equipo sepa qué servidores existen y para qué sirven.

Taller de diseño de una política MCP para un equipo grande con varios repositorios.

Revisión del aviso oficial de Anthropic sobre el riesgo de usar MCP de terceros no verificados.

Identificación de escenarios donde un servidor que trae contenido no confiable puede exponer al agente a prompt injection.

Construcción de criterios de confianza sobre origen, permisos, ámbito y capacidad de acción del servidor conectado.

Preparación de procedimientos de validación para MCP internos y externos antes de habilitarlos en proyecto.

Detección de integraciones que conviene mantener solo en local o solo en entornos sandbox.

Relación entre superficie de herramientas y riesgo operativo dentro del flujo de desarrollo.

Revisión de patrones para limitar el daño potencial cuando el contenido externo es inevitable.

Preparación de una política de seguridad que distinga claramente lectura, acción y canales.

Construcción de ejercicios de threat modeling sobre MCP aplicados al repositorio real.

Taller de análisis de riesgo sobre una arquitectura MCP avanzada.

Comprensión de por qué los subagentes son valiosos cuando una tarea lateral inundaría la conversación principal.

Revisión de la ventaja de trabajar con contextos separados para investigación, revisión, testing o refactor por áreas.

Construcción de criterios para decidir cuándo crear un subagente y cuándo resolver con el agente principal.

Detección de casos donde la especialización mejora foco y de otros donde solo fragmenta el trabajo innecesariamente.

Preparación de taxonomías de subagentes por rol: reviewer, architect, test-runner, migration-helper, security-auditor.

Relación entre separación de contexto y reducción del coste cognitivo del flujo principal.

Revisión de cómo escribir descripciones que ayuden a Claude a delegar automáticamente en el subagente adecuado.

Construcción de una estrategia para subagentes transversales y subagentes específicos por repo.

Detección de anti-patrones en subagentes demasiado genéricos o demasiado superpuestos.

Taller de diseño de un catálogo inicial de subagentes de equipo.

Revisión del formato oficial de subagentes como archivos Markdown con YAML frontmatter.

Uso avanzado de campos como `tools`, `disallowedTools`, `model`, `permissionMode`, `maxTurns`, `skills`, `mcpServers`, `hooks` y `memory`.

Construcción de prompts de sistema realmente especializados y no simples resúmenes de tarea.

Preparación de subagentes orientados a lectura, a escritura, a validación o a análisis de impacto.

Revisión de cómo elegir modelo y permiso por subagente según coste, riesgo y criticidad.

Detección de casos donde conviene `inherit` y otros donde conviene fijar modelo explícito.

Construcción de subagentes que cargan contexto y tooling justo, sin arrastrar sobreconfiguración.

Preparación de subagentes con memoria persistente donde el caso lo justifique.

Relación entre buen frontmatter y menor fricción al reutilizar el agente en sesiones futuras.

Taller de definición completa de varios subagentes avanzados con objetivos distintos.

Revisión de los scopes oficiales de subagentes: usuario y proyecto, y su ubicación en `.claude/agents/` o `~/.claude/agents/`.

Construcción de una estrategia para decidir qué subagentes deben vivir en el repo y cuáles deben quedar como personales.

Detección de riesgos de compartir agentes demasiado idiosincráticos o demasiado inmaduros.

Preparación de workflows de revisión y versionado de subagentes dentro de git.

Relación entre subagentes compartidos y estandarización efectiva del trabajo del equipo.

Revisión de conflictos de nombre y prioridad cuando un mismo nombre aparece en varios scopes.

Construcción de convenciones de naming y de documentación breve para el catálogo interno.

Preparación de una política de lifecycle para crear, revisar, deprecar y sustituir agentes.

Detección de subagentes que conviene migrar a skill, a hook o a plugin en vez de mantener como agente.

Taller de diseño de una estrategia de scopes para un equipo senior.

Comprensión de los agent teams como sesiones independientes de Claude Code coordinadas por un lead.

Revisión de cómo dividir trabajo en paralelo para exploración, revisión, implementación y validación.

Construcción de criterios para usar varios teammates en tareas complejas y evitar sobrecoste en tareas rutinarias.

Preparación de instrucciones de spawn claras para obtener nombres, roles y objetivos predecibles.

Relación entre task list compartida y coordinación efectiva entre agentes.

Revisión de la aprobación de planes para teammates en tareas riesgosas o complejas.

Detección de cuándo el equipo de agentes necesita plan first y cuándo puede ir directo a implementación.

Construcción de un modelo de orquestación donde el lead conserve visión global sin microgestionar cada paso.

Preparación de patrones para equipos temporales orientados a refactors, migraciones o incident response.

Taller de diseño de una topología de agentes para una tarea compleja de ingeniería.

Uso de definiciones de subagente como base para teammates en agent teams.

Revisión de cómo el teammate hereda `tools` y `model`, y cómo se incorpora el cuerpo del subagente al system prompt.

Comprensión de que `skills` y `mcpServers` del frontmatter del subagente no se aplican cuando corre como teammate.

Construcción de patrones para reutilizar roles especializados sin duplicar definición.

Detección de confusiones comunes al esperar que el teammate replique exactamente el comportamiento del subagente suelto.

Preparación de estrategias para complementar teammates con settings y proyecto en lugar de cargar todo en el frontmatter.

Relación entre reusabilidad de roles y velocidad de arranque de equipos agentic.

Revisión de cómo los permisos del lead impactan directamente a los teammates.

Construcción de una política de reutilización segura para agentes de seguridad, testing y revisión.

Taller de conversión de un catálogo de subagentes en un sistema de agent teams reusable.

Comprensión del valor de los hooks como capa de control determinista frente a comportamientos que no conviene delegar a elección del LLM.

Revisión del ciclo de vida oficial y de eventos como `PreToolUse`, `PostToolUse`, `TaskCreated`, `TaskCompleted`, `SubagentStart`, `FileChanged`, `Stop`, `PreCompact` y otros.

Construcción de una taxonomía de hooks preventivos, correctivos, informativos y de auditoría.

Preparación de hooks que bloqueen, filtren, notifiquen, reformateen o inyecten contexto en momentos clave.

Detección de casos donde un hook añade fiabilidad real y casos donde solo mete latencia y ruido.

Relación entre hooks bien elegidos y menor dependencia del “por favor acuérdate de…”.

Revisión del papel de matchers y del campo `if` para evitar spawns innecesarios.

Construcción de una arquitectura de hooks por repositorio, por fase del workflow y por tipo de herramienta.

Preparación de un patrón de documentación para que el equipo entienda por qué existe cada hook.

Taller de diseño de arquitectura de hooks para un monorepo con políticas de equipo.

Revisión de los tipos de hook soportados hoy: shell commands, HTTP endpoints y LLM prompts.

Construcción de criterios para decidir cuándo usar un script local, cuándo exponer un endpoint y cuándo pedir juicio a un hook basado en modelo.

Preparación de hooks de shell para lint, format, validación de rutas y bloqueo de acciones peligrosas.

Uso de hooks HTTP para delegar decisiones o integrarse con servicios de política, logging o notificación.

Revisión de hooks basados en prompt o agente cuando la regla requiere criterio y no una simple condición binaria.

Detección de anti-patrones donde un hook LLM complica lo que un script resolvería mejor.

Construcción de capas de automatización donde diferentes tipos de hook conviven sin duplicar lógica.

Preparación de fallback y observabilidad para hooks remotos o dependientes de otros sistemas.

Relación entre complejidad del hook y coste de mantenimiento futuro.

Taller de implementación de varios hooks con tipos distintos sobre un mismo workflow.

Revisión de la capacidad oficial para ejecutar hooks en background y de su valor en flujos pesados.

Construcción de estrategias para mover fuera del contexto de Claude pasos como filtrado de logs, agrupación de errores o preparación de datos.

Preparación de hooks asíncronos que no bloqueen innecesariamente la interacción principal.

Detección de cuándo un hook síncrono está degradando la experiencia del desarrollador o el rendimiento del agente.

Revisión del uso de hooks para reducir tokens preprocesando información antes de que Claude la vea.

Construcción de patrones de offloading para pruebas, análisis de artefactos y lectura de outputs muy grandes.

Preparación de límites y timeouts razonables para no dejar procesos asíncronos fuera de control.

Relación entre rendimiento del hook y estabilidad global del flujo de trabajo de Claude Code.

Detección de situaciones donde la optimización prematura con hooks no compensa.

Taller de diseño de pipeline de preprocesado con hooks asíncronos.

Uso de `PreToolUse` y otros eventos para bloquear comandos destructivos, rutas sensibles o patrones prohibidos.

Construcción de hooks que impidan editar secretos, archivos críticos de infraestructura o directorios protegidos.

Preparación de validaciones sobre mensajes, permisos o acciones antes de que el agente ejecute cambios irreversibles.

Detección de los puntos donde el guardrail debe ser técnico y no solo cultural.

Relación entre hooks de seguridad y reducción del riesgo operativo al trabajar con agentes más autónomos.

Revisión de cómo auditar cambios de configuración y eventos relevantes del ciclo de vida.

Preparación de políticas de aprobación automática muy acotadas frente a políticas de denegación dura.

Construcción de una capa de cumplimiento compatible con equipos que ya usan `--dangerously-skip-permissions` en ciertos contextos.

Detección de trade-offs entre velocidad y control en hooks de seguridad.

Taller de diseño de un paquete de guardrails para un repositorio crítico.

Revisión de cómo combinar herramientas conectadas, agentes especializados y control determinista sin montar un sistema inmanejable.

Construcción de workflows donde un subagente usa MCP para investigar, otro implementa y hooks validan antes y después de cada acción.

Preparación de patrones para separar investigación externa, modificación de código y enforcement de reglas.

Detección de acoplamientos peligrosos entre agentes y herramientas externas.

Relación entre buena composición y productividad sostenida del equipo.

Revisión de escenarios donde la complejidad combinada compensa y escenarios donde no.

Preparación de un modelo de capas que haga el sistema explicable a nuevos miembros del equipo.

Construcción de diagramas de interacción entre Claude principal, subagentes, MCP y hooks.

Detección de fallos de diseño cuando todo depende del prompt del usuario y no de la arquitectura montada.

Taller de diseño de una arquitectura combinada para una feature compleja.

Comprensión de Claude Code GitHub Actions como automatización sobre PRs e issues, no solo como ejecución puntual en CI.

Revisión del uso de `@claude` para activar análisis, implementación o creación de PRs desde issues o comentarios.

Construcción de un flujo de setup rápido con `/install-github-app` y comprensión de sus prerrequisitos.

Revisión de los permisos mínimos del GitHub App: Contents, Issues y Pull Requests con lectura y escritura.

Detección de riesgos de habilitar la app sin criterio de repos, ramas o secretos.

Preparación de un esquema de secretos y permisos que no sobreexponga el repositorio.

Relación entre GitHub runners y el carácter “secure by default” del flujo documentado por Anthropic.

Construcción de un modelo de rollout por repositorio o por tipo de workflow.

Revisión de límites y consideraciones cuando se usa Bedrock o Vertex frente a API directa.

Taller de setup completo de Claude Code GitHub Actions.

Diseño de workflows donde Claude implementa cambios a partir de una issue bien definida.

Preparación de automatizaciones sobre PRs para análisis, cambios, respuestas y seguimiento de comentarios.

Revisión de cómo usar `CLAUDE.md` para que las acciones sigan patrones y estándares del proyecto.

Construcción de flujos de triage, refactor, code generation y bugfix asistido desde GitHub.

Detección de casos donde conviene intervención automática y otros donde debe haber trigger explícito.

Preparación de prompts de workflow que complementen `CLAUDE.md` sin duplicarlo.

Relación entre calidad de la issue/PR y calidad del resultado generado por la acción.

Construcción de procesos para code review interno y corrección iterativa dentro del workflow.

Revisión de la diferencia entre review automático por PR y ejecución disparada por mención.

Taller de diseño de varios workflows de automatización sobre GitHub.

Revisión del hecho de que la acción se apoya en Claude Agent SDK, lo que abre la puerta a automatizaciones más allá del ejemplo básico.

Construcción de workflows que usen prompts de acción muy concretos según tipo de trigger.

Preparación de patrones donde el repositorio aporta `CLAUDE.md`, skills y estándares reutilizables al flujo de CI.

Revisión del uso dinámico de MCP dentro de GitHub Actions cuando el workflow necesita contexto externo.

Detección de límites de complejidad a partir de los cuales conviene mover lógica fuera del workflow YAML.

Construcción de acciones separadas para review, implementación, documentación y mantenimiento.

Preparación de flujos con diferentes modelos según criticidad o coste.

Relación entre tiempo de ejecución, timeouts y diseño de prompts adecuados para CI.

Construcción de estrategias de branching y commit que encajen con la intervención del agente.

Taller de workflow avanzado de GitHub Actions con integración externa.

Revisión de cómo el uso de subagentes y agent teams incrementa el consumo de tokens al añadir contextos independientes.

Construcción de criterios para usar Sonnet, Opus o Haiku según tipo de tarea, criticidad y retorno esperado.

Preparación de hooks y skills para reducir contexto y coste en sesiones largas o automatizadas.

Detección de flujos donde la sofisticación del sistema añade más coste que valor práctico.

Revisión de cómo separar tareas rutinarias de tareas complejas para no sobredimensionar el uso de agentes.

Construcción de estrategias de compactación, resumido y segmentación de trabajo.

Relación entre arquitectura de contexto y consumo real en equipos grandes.

Preparcción de estrategias de compactación, resumido y segmentación de trabajo.

Relación de guid y costes, live sessions o periodos de alta concurrencia.

Detección de cuellos de botella técnicos y económicos al escalar Claude Code en un equipo completo.

Taller de optimización de arquitectura agentic para coste y rendimiento.

Comprensión del papel del Calude Code Settions en las políticas de seguridad y cumplimiento no overrideables.

Revisión de allowlists de MCP y aplicación global de hooks y otras restricciones gestionadas.

Construcción de una estrategia de despliegue donde TI/DevOps fija mínimos y los equipos conservan flexibilidad razonable.

Preparación de políticas distintas para repos críticos, repos experimentales y repos de formación.

Detección de excesos de control que bloquean adopción y excesos de libertad que rompen seguridad.

Relación entre gobernanza madura y confianza del equipo en el sistema.

Preparación de un operating model para soporte, actualización y revisión del stack de Claude Code.

Revisión de cómo documentar cambios en hooks, MCP y subagentes para auditoría interna.

Construcción de un marco organizativo que permita escalar sin multiplicar configuraciones incompatibles.

Taller de diseño de gobierno empresarial para Claude Code avanzado.

Selección de un repositorio o stack de práctica con suficiente complejidad para justificar MCP, subagentes, hooks y GitHub Actions.

Diagnóstico de tareas repetitivas, riesgos, fricción operativa y puntos de automatización con mayor retorno.

Diseño de la arquitectura completa de `.claude`, `CLAUDE.md`, scopes y reglas compartidas.

Implementación de una capa MCP útil, segura y con propósito claro dentro del flujo del proyecto.

Creación de un catálogo inicial de subagentes reutilizables para roles técnicos diferenciados.

Construcción de hooks que aporten control, validación y automatización sin degradar la experiencia de desarrollo.

Integración de uno o varios workflows de GitHub Actions alineados con el ciclo de trabajo del equipo.

Revisión de coste, seguridad, mantenibilidad y puntos de fallo de la solución propuesta.

Presentación del caso con enfoque técnico, operativo y de gobierno.

Entrega de un blueprint reusable para adopción avanzada de Claude Code en equipos de ingeniería.