Curso de Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions
Aprende con el curso de Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions para empresas hasta 100% bonificado, a medida para tu organización.
Totalmente práctico y aplicable
Formación en Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions a medida
Curso de Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions hasta 100% Bonificable a través de FUNDAE
Tu bonificación paso a paso
Forma a tu equipo sin costes mediante la bonificación estatal. Este programa de Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actionspara empresas es subvencionable hasta el 100%.
Potencia las habilidades de edición y automatización de tus profesionales.
Accede a una formación avanzada en Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions práctica y orientada a resultados.
Prepara a tu equipo para los retos documentales del entorno laboral actual.
Gestionamos gratis tu bonificación de este curso corporativo de Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions ante FUNDAE.
Lleva Claude Code al nivel de arquitectura operativa
Impulsa a tu equipo con Claude Code Avanzado, MCP, Subagentes, Hooks y GitHub Actions. Formación A Medida bonificable hasta el 100% por FUNDAE. Infórmate.
Ordena extensiones que suelen adoptarse de forma caótica Muchos equipos empiezan a usar MCP, hooks o subagentes por separado y terminan con un sistema difícil de explicar o mantener. El curso aporta criterio para componer esas piezas de manera coherente, con objetivos claros y con una lógica de gobierno que evita bastante fricción futura.
1
Personaliza el temario al 100% para tu equipo
Diseñamos una formación a medida utilizando los documentos y flujos de trabajo reales de tu empresa.
Nueva Plataforma de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Programa formativo
Temario del curso
Encuentra todo el temario del curso aquí.
Temario
Revisión del bucle agentic real de Claude Code y de cómo combina lectura del repositorio, herramientas, ejecución y contexto para resolver tareas complejas.
Diferenciación entre pedir una corrección puntual y diseñar un flujo de trabajo donde Claude actúe con autonomía acotada y controlada.
Análisis del valor de Claude Code en repositorios donde ya existe complejidad técnica, deuda, tooling heterogéneo y múltiples capas de validación.
Detección de los límites del uso “manual” de Claude Code cuando el equipo ya trabaja intensivamente con él.
Construcción de una visión avanzada en la que MCP, hooks y subagentes actúan como extensiones del sistema y no como extras aislados.
Revisión de cómo la misma lógica agentic se mantiene entre terminal, IDE, navegador o CI aunque cambie la interfaz operativa.
Relación entre madurez del equipo y necesidad de formalizar contexto, permisos, automatización y especialización de agentes.
Identificación de anti-patrones comunes en equipos que ya usan Claude Code pero siguen dependiendo demasiado del prompt improvisado.
Construcción de un marco de decisión para saber cuándo resolver con una sola sesión y cuándo dividir trabajo en múltiples componentes.
Taller de diagnóstico del nivel de madurez actual del uso de Claude Code en el equipo.
Revisión del bucle agentic real de Claude Code y de cómo combina lectura del repositorio, herramientas, ejecución y contexto para resolver tareas complejas.
Diferenciación entre pedir una corrección puntual y diseñar un flujo de trabajo donde Claude actúe con autonomía acotada y controlada.
Análisis del valor de Claude Code en repositorios donde ya existe complejidad técnica, deuda, tooling heterogéneo y múltiples capas de validación.
Detección de los límites del uso “manual” de Claude Code cuando el equipo ya trabaja intensivamente con él.
Construcción de una visión avanzada en la que MCP, hooks y subagentes actúan como extensiones del sistema y no como extras aislados.
Revisión de cómo la misma lógica agentic se mantiene entre terminal, IDE, navegador o CI aunque cambie la interfaz operativa.
Relación entre madurez del equipo y necesidad de formalizar contexto, permisos, automatización y especialización de agentes.
Identificación de anti-patrones comunes en equipos que ya usan Claude Code pero siguen dependiendo demasiado del prompt improvisado.
Construcción de un marco de decisión para saber cuándo resolver con una sola sesión y cuándo dividir trabajo en múltiples componentes.
Taller de diagnóstico del nivel de madurez actual del uso de Claude Code en el equipo.
Tema 1: Claude Code como sistema agentic de desarrollo y no como simple asistente CLI
Revisión del bucle agentic real de Claude Code y de cómo combina lectura del repositorio, herramientas, ejecución y contexto para resolver tareas complejas.
Diferenciación entre pedir una corrección puntual y diseñar un flujo de trabajo donde Claude actúe con autonomía acotada y controlada.
Análisis del valor de Claude Code en repositorios donde ya existe complejidad técnica, deuda, tooling heterogéneo y múltiples capas de validación.
Detección de los límites del uso “manual” de Claude Code cuando el equipo ya trabaja intensivamente con él.
Construcción de una visión avanzada en la que MCP, hooks y subagentes actúan como extensiones del sistema y no como extras aislados.
Revisión de cómo la misma lógica agentic se mantiene entre terminal, IDE, navegador o CI aunque cambie la interfaz operativa.
Relación entre madurez del equipo y necesidad de formalizar contexto, permisos, automatización y especialización de agentes.
Identificación de anti-patrones comunes en equipos que ya usan Claude Code pero siguen dependiendo demasiado del prompt improvisado.
Construcción de un marco de decisión para saber cuándo resolver con una sola sesión y cuándo dividir trabajo en múltiples componentes.
Taller de diagnóstico del nivel de madurez actual del uso de Claude Code en el equipo.
Tema 2: Scopes, configuración compartida y arquitectura del directorio .claude
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.
Tema 3: CLAUDE.md avanzado, memoria de proyecto y contexto estructural
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.
Tema 4: MCP avanzado: cuándo conecta valor real y cuándo solo añade complejidad
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.
Tema 5: MCP remoto por HTTP, autenticación y patrón de integración moderno
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.
Tema 6: MCP local por stdio, scripts internos y tooling del repositorio
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.
Tema 7: Gestión, scopes y gobierno de servidores MCP
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.
Tema 8: Seguridad en MCP: prompt injection, confianza y superficie de ataque
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.
Tema 9: Subagentes: diseño de especialización y partición de contexto
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.
Tema 10: Subagentes en Markdown + YAML frontmatter: diseño correcto y campos avanzados
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.
Tema 11: Subagentes por scope, versionado y compartición en equipo
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.
Tema 12: Agent teams, teammate orchestration y paralelización de trabajo
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.
Tema 13: Reutilizar subagentes como teammates y límites reales de esa reutilización
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.
Tema 14: Hooks avanzados: arquitectura de eventos y control determinista
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.
Tema 15: Hooks de comando, HTTP, prompt y agent-based
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.
Tema 16: Hooks asíncronos, rendimiento y offloading de trabajo pesado
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.
Tema 17: Hooks de seguridad, compliance y guardrails del repositorio
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.
Tema 18: MCP + hooks + subagentes: composición avanzada de extensiones
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.
Tema 19: GitHub Actions con Claude Code: fundamentos, setup y seguridad operativa
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.
Tema 20: GitHub Actions para issues, PRs y automatización de desarrollo
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.
Tema 21: GitHub Actions avanzadas: prompts, skills, MCP y workflows personalizados
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.
Tema 22: Coste, rendimiento y escalabilidad operativa del stack avanzado
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.
Tema 23: Gobierno organizativo, settings gestionados y estandarización empresarial
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.
Tema 24: Proyecto final integrador: arquitectura avanzada de Claude Code en un repositorio real
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.
Perfiles profesionales
Pensado para quienes deben dominar Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions en su día a día
Ingenieros backend y full stack
Este perfil encaja especialmente bien porque suele trabajar con repositorios complejos, integración con herramientas externas, múltiples flujos de validación y tareas de implementación que se benefician mucho de una orquestación más madura. El curso le ayuda a pasar de un uso eficaz de Claude Code a un uso estructurado, con subagentes especializados, hooks que refuerzan reglas y MCP conectado al stack real del equipo.
Ingenieros de plataforma, DevOps y SRE
Quienes sostienen herramientas internas, pipelines, automatización, observabilidad y gobierno técnico encuentran aquí un encaje muy claro. La formación les permite tratar Claude Code como una pieza del sistema de desarrollo: con configuración compartida, restricciones gestionadas, integración con GitHub Actions y conexión a servicios externos mediante MCP, todo ello con una lógica de seguridad y mantenibilidad.
Preguntas frecuentes
Resolvemos todas tus dudas sobre nuestra formación en Claude Code Avanzado: MCP, Subagentes, Hooks y GitHub Actions
Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.
No. Está pensado para personas que ya trabajan habitualmente con Claude Code y necesitan ir a la capa avanzada: arquitectura de configuración, MCP, subagentes, hooks, agent teams y GitHub Actions. Claude Code se documenta hoy como extensiones precisamente en esas capas.
Conviene trabajar con HTTP cuando exista esa opción. La documentación actual indica que para servidores remotos HTTP es la opción recomendada y que SSE mantiene la opción de stdio para servidores locales.
Sí. La documentación oficial permite definir en el frontmatter de un subagente campos como `tools`, `disallowedTools`, `model`, `permissionMode`, `maxTurns`, `skills`, `mcpServers`, `hooks` y `memory`. Además, los subagentes se definen en scope de usuario o de proyecto.
Sí. Los teammates pueden reutilizar definiciones de subagente por nombre, y heredan su `tools` allowlist y su `model`. Eso sí, cuando una definición de subagente se usa como teammate, los campos `skills` y `mcpServers` del frontmatter no se aplican como skills y MCP desde settings del proyecto y del usuario.
Claude Code soporta hooks como shell commands, HTTP endpoints y también hooks basados en LLM prompts. La referencia oficial cubre además eventos de todo el ciclo de vida, asíncronos, hooks HTTP y MCP tool hooks
Sí. La documentación actual indica que el scope de proyecto es el adecuado para configuraciones compartidas por equipo, incluyendo permissions, hooks y scope vive dentro de `.claude/` en el repositorio.
Sirve para ambas cosas. La documentación oficial indica que con una simple mención `@claude` en una PR o una issue Claude puede analizar código, crear pull requests, implementar features y corregir bugs. Además, la integración está construida sobre Claude workflows personalizados más allá del caso básico.
La guía oficial recomienda el setup rápido desde terminal con `/install-github-app`, para el que debes ser repository admin. El GitHub App requiere permisos de Contents, Issues y Pull requests, todos con read & write. Estándares y criterios del proyecto.
Sí. En contexto corporativo, esta formación puede plantearse como bonificable hasta el 100% si la empresa dispone de crédito suficiente y tramita correctamente la acción formativa conforme al marco aplicable.
No. Está pensado para personas que ya trabajan habitualmente con Claude Code y necesitan ir a la capa avanzada: arquitectura de configuración, MCP, subagentes, hooks, agent teams y GitHub Actions. Claude Code se documenta hoy como extensiones precisamente en esas capas.
Conviene trabajar con HTTP cuando exista esa opción. La documentación actual indica que para servidores remotos HTTP es la opción recomendada y que SSE mantiene la opción de stdio para servidores locales.
Sí. La documentación oficial permite definir en el frontmatter de un subagente campos como `tools`, `disallowedTools`, `model`, `permissionMode`, `maxTurns`, `skills`, `mcpServers`, `hooks` y `memory`. Además, los subagentes se definen en scope de usuario o de proyecto.
Sí. Los teammates pueden reutilizar definiciones de subagente por nombre, y heredan su `tools` allowlist y su `model`. Eso sí, cuando una definición de subagente se usa como teammate, los campos `skills` y `mcpServers` del frontmatter no se aplican como skills y MCP desde settings del proyecto y del usuario.
Claude Code soporta hooks como shell commands, HTTP endpoints y también hooks basados en LLM prompts. La referencia oficial cubre además eventos de todo el ciclo de vida, asíncronos, hooks HTTP y MCP tool hooks
Sí. La documentación actual indica que el scope de proyecto es el adecuado para configuraciones compartidas por equipo, incluyendo permissions, hooks y scope vive dentro de `.claude/` en el repositorio.
Sirve para ambas cosas. La documentación oficial indica que con una simple mención `@claude` en una PR o una issue Claude puede analizar código, crear pull requests, implementar features y corregir bugs. Además, la integración está construida sobre Claude workflows personalizados más allá del caso básico.
La guía oficial recomienda el setup rápido desde terminal con `/install-github-app`, para el que debes ser repository admin. El GitHub App requiere permisos de Contents, Issues y Pull requests, todos con read & write. Estándares y criterios del proyecto.
Sí. En contexto corporativo, esta formación puede plantearse como bonificable hasta el 100% si la empresa dispone de crédito suficiente y tramita correctamente la acción formativa conforme al marco aplicable.
Diseñemos hoy el curso que tu empresa necesita
Cuéntanos tus objetivos de negocio y prepararemos una propuesta formativa bonificable totalmente ad hoc
Refuerza seguridad y control sin matar productividad Otra ventaja muy importante es que trata seguridad y permisos como parte del diseño, no como una revisión posterior. Esto se nota especialmente en MCP, hooks de guardrail y GitHub Actions, donde una mala configuración puede generar más riesgo del que el equipo percibe al principio.
2
Mejora la reutilización y reduce dependencia del prompt improvisado El valor del programa no está solo en saber más, sino en depender menos del talento individual de cada sesión. Con subagentes bien definidos, hooks útiles, `CLAUDE.md` bien construido y workflows compartidos, el equipo gana mucha más consistencia y menor variabilidad entre desarrolladores.
3
Conecta repositorio, herramientas externas y CI/CD Otra gran ventaja es que integra el trabajo local con herramientas externas y con GitHub Actions. Eso permite cerrar el circuito completo entre desarrollo, contexto de negocio o tooling y automatización de repositorio, algo especialmente valioso en equipos maduros que quieren reducir trabajo manual de verdad.
4
Encaja perfectamente en equipos que ya usan Claude Code intensivamente Este no es un curso de iniciación. Precisamente por eso su retorno es muy alto en equipos que ya trabajan con Claude Code y notan que el siguiente salto ya no está en “usar mejor el chat”, sino en diseñar mejor el sistema alrededor de Claude Code.
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Ejercicios prácticos
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Practica y mejora con nuestra plataforma
Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.
Correccion magica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
Staff engineers, tech leads y responsables de arquitectura técnica
Este perfil obtiene mucho valor porque necesita decidir cómo se trabaja, no solo cómo se programa. El curso le aporta criterio para definir subagentes por rol, gobernar permisos, decidir cuándo usar hooks deterministas frente a automatización en CI, y convertir Claude Code en una capacidad de equipo y no en una herramienta individual desordenada.
Equipos de desarrollo que ya usan Claude Code de forma intensiva
Para estos perfiles, la formación resulta especialmente útil porque no parte de cero. Se centra en lo que viene después de la adopción inicial: extender con MCP, separar trabajo por agentes, reforzar flujos con hooks, automatizar con GitHub Actions y reducir el coste cognitivo y operativo de los repositorios complejos.
Equipos de QA técnico, test engineering y automation
Quienes trabajan con regresión, cobertura, análisis de fallos, validación de cambios y pipelines de calidad pueden sacar mucho partido del curso. Aprenden a usar hooks para forzar validaciones, subagentes para repartir revisión, MCP para conectar herramientas del ciclo de calidad y GitHub Actions para automatizar intervención sobre issues y PRs.
Organizaciones que quieren estandarizar Claude Code por proyecto o por empresa
Este perfil encaja especialmente bien porque la formación no se queda en el uso del desarrollador individual. También cubre scopes, settings compartidos, configuración gestionada, allowlists y denylists de MCP, políticas de hooks y despliegue del trabajo automatizado con GitHub, lo que permite convertir Claude Code en una práctica organizativa más seria y no en una suma de hábitos dispersos.