Módulo 7: Integraciones: Git, SDK, y Remote Control
Módulo 7: Integraciones — Git, SDK, Remote Control y más
Módulo 7: Integraciones — Git, SDK, Remote Control y más
Descripción
Has recorrido un camino largo. Sabes qué es Claude Code, lo tienes instalado, configuraste CLAUDE.md para darle memoria persistente, dominas el workflow Explore → Plan → Code, creaste skills y hooks para personalizar su comportamiento, y aprendiste a delegar trabajo con subagents. Claude Code ya no es una herramienta genérica — es un agente configurado para tu proyecto, tu equipo, y tu workflow.
Pero hasta ahora, Claude Code ha operado en un contexto relativamente aislado: tú le hablas, él responde, ejecuta tareas, y el ciclo se repite. ¿Qué pasa cuando necesitas que Claude Code interactúe con el mundo exterior? ¿Que haga commits en Git? ¿Que se ejecute programáticamente desde un script de Python? ¿Que se conecte con APIs externas? ¿Que lo controles desde tu móvil mientras estás lejos del escritorio?
Ese es el tema de este módulo: las integraciones. Cómo Claude Code se conecta con tu infraestructura de desarrollo existente — Git, SDKs, pipelines de CI/CD, y herramientas externas. Es el puente entre "usar Claude Code en la terminal" y "integrar Claude Code en tu stack completo".
Features recientes (marzo-abril 2026)
Claude Code evoluciona rápidamente. Estos son los features más importantes lanzados en los últimos 2 meses que afectan este módulo:
| Feature | Estado | Cápsula donde se cubre |
|---|---|---|
| Computer Use en Claude Code Desktop | Marzo 2026 | Cápsula 05 |
| Computer Use en Claude Code CLI | Research preview (abril 2026) | Cápsula 05 |
| PR Auto-fix en Claude Code on the Web | Marzo 2026 | Cápsula 02 (Git workflows) |
/autofix-pr (PR auto-fix desde terminal) | Abril 2026 | Cápsula 02 |
Transcript search (Ctrl+O + /) | Marzo 2026 | Cápsula 04 (Headless/CLI) |
| PowerShell tool nativo para Windows | Marzo 2026 (preview) | Cápsula 02/04 |
/team-onboarding (package tu setup) | Abril 2026 | Cápsula 04 |
/loop (self-pace o interval) | Abril 2026 | Cápsula 04 |
| Ultraplan (planning CLI ↔ web) | Early preview (abril 2026) | Cápsula 05 |
| Monitor tool (stream events en vivo) | Abril 2026 | Cápsula 05 |
| Auto Mode (permission classifier) | Research preview (marzo 2026) | Cubierto en M05 cap 05 |
Dónde estamos en la guía
Módulo 01: Qué es Claude Code ✅
Módulo 02: Instalación y setup ✅
Módulo 03: CLAUDE.md y memoria ✅
Módulo 04: Workflow agentic ✅
Módulo 05: Skills y Hooks ✅
Módulo 06: Subagents ✅
Módulo 07: Integraciones (Git, SDK, Remote Control) ← ESTÁS AQUÍ
Módulo 08: Proyecto integrador
Los módulos 01-03 fueron configuración: instalar, configurar, dar contexto. Los módulos 04-06 fueron workflow: cómo trabajar con Claude Code, personalizarlo, y escalar con subagents. Este módulo es conexión: cómo Claude Code se integra con las herramientas que ya usas.
Por qué las integraciones importan
Claude Code como componente, no como isla
Un agente de código que solo opera en modo interactivo tiene un límite claro: requiere que estés frente a la terminal, escribiendo prompts, aprobando acciones, revisando resultados. Eso funciona para tareas puntuales, pero no escala.
Las integraciones transforman Claude Code de una herramienta interactiva a un componente programable de tu stack:
┌──────────────────────────────────────────────────────────────┐
│ SIN INTEGRACIONES │
│ │
│ Tú ──▶ Terminal ──▶ Claude Code ──▶ Terminal ──▶ Tú │
│ │
│ (loop cerrado, manual, sincrónico) │
└──────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────┐
│ CON INTEGRACIONES │
│ │
│ Git ──────────────────▶ Claude Code ◀──── CI/CD pipeline │
│ SDK (Python/TS) ──────▶ Claude Code ◀──── Cron jobs │
│ MCP servers ──────────▶ Claude Code ◀──── Pre-commit hooks │
│ Remote Control ───────▶ Claude Code ◀──── Otros agentes │
│ │
│ (ecosistema abierto, programable, asíncrono) │
└──────────────────────────────────────────────────────────────┘
Las 4 dimensiones de integración
Este módulo cubre 4 dimensiones que, juntas, hacen de Claude Code un componente completo:
| Dimensión | Qué resuelve | Cápsula |
|---|---|---|
| Git | Control de versiones integrado en el workflow | 02 |
| SDK | Acceso programático desde Python/TypeScript | 03 |
| Headless CLI | Automatización sin interacción humana | 04 |
| MCP + Remote | Conexión con herramientas externas y control remoto | 05 |
Cada dimensión resuelve un problema diferente. Git resuelve "cómo versionar el trabajo de Claude Code". El SDK resuelve "cómo usar Claude Code desde código". El headless mode resuelve "cómo automatizar Claude Code en scripts". MCP resuelve "cómo darle a Claude Code acceso a datos y APIs externas".
Qué aprenderás en cada cápsula
Cápsula 01 — Introducción al módulo (esta cápsula)
Contexto, mental model, y roadmap. Entiendes qué son las integraciones, por qué importan, y cómo conectan Claude Code con tu stack.
Cápsula 02 — Git workflows
Cómo Claude Code trabaja con Git de forma nativa. Commits semánticos, branches, Pull Requests con gh, code review sobre diffs, resolución de conflictos. Patterns de workflow: feature branch, commit-as-you-go, review-before-commit. Conventional commits y buenas prácticas.
Cápsula 03 — Claude Agent SDK (Python y TypeScript)
Acceso programático a Claude Code. El Claude Agent SDK de Python (claude-agent-sdk) y TypeScript (@anthropic-ai/claude-agent-sdk). La función query(), streaming, outputs estructurados. Cuándo usar el SDK vs modo interactivo. Scripts prácticos para code review, documentación, y batch processing.
Nota de naming: Anteriormente se llamaba "Claude Code SDK". Anthropic lo renombró a Claude Agent SDK porque la misma harness sirve para construir cualquier agente, no solo agentes de código.
Cápsula 04 — Headless mode CLI
El flag -p para ejecutar Claude Code sin interacción. Formatos de salida (text, json, stream-json). Piping de input. Combinación con otros flags (--model, --max-tokens, --no-permissions). Scripts prácticos: review automatizado, generador de docs, PR descriptions. Headless vs SDK: cuándo usar cada uno.
Cápsula 05 — MCP y Remote Control
Model Context Protocol para conectar Claude Code con fuentes de datos externas. Setup básico de MCP servers (filesystem, GitHub, bases de datos). Remote Control desde móvil (research preview). MCP como puente hacia la Guía #5 de esta serie.
Mapa de progresión
Cápsula 01 (esta) → Contexto y mental model
Cápsula 02 → Git: control de versiones integrado
Cápsula 03 → SDK: acceso programático
Cápsula 04 → Headless CLI: automatización
Cápsula 05 → MCP + Remote: conexiones externas
Dificultad: ⭐ ──────────────────────────▶ ⭐⭐⭐⭐
Las cápsulas 02-03 son fundamentales — Git y SDK son las integraciones más usadas. La cápsula 04 es intermediate — headless mode para automatización. La cápsula 05 es avanzada/exploratoria — MCP y Remote Control incluyen features experimentales.
Prerequisitos
Conocimiento requerido:
- ✅ Módulo 06 completado (Subagents)
- ✅ Módulo 04 completado (Workflow Explore → Plan → Code dominado)
- ✅ CLAUDE.md configurado en tu proyecto (Módulo 03)
- ✅ Claude Code instalado y funcionando (Módulo 02)
Para la práctica:
- ✅ Git instalado y configurado (
git --versionfunciona) - ✅ Un repositorio Git con historial (al menos 10 commits)
- ✅ Python 3.8+ y/o Node.js 18+ (para ejercicios de SDK)
- ✅
ghCLI instalado (para ejercicios de Pull Requests) - ✅ Conocimiento básico de Git (commits, branches, merge)
Verificación rápida:
Antes de continuar, verifica que puedes responder estas preguntas:
- ¿Qué es un subagent y cómo se diferencia de un skill?
- ¿Cuáles son los subagents built-in de Claude Code?
- ¿Qué es el parent-child model en subagents?
Respuestas
- Un subagent es un agente separado con su propio contexto, optimizado para una tarea específica. Un skill es un archivo markdown con instrucciones que Claude lee bajo demanda. Si la tarea necesita instrucciones → skill. Si necesita un agente dedicado con razonamiento propio → subagent.
- Explore (análisis read-only), Plan (diseño sin ejecución), General-purpose (ejecución completa), más utilitarios como statusline-setup y claude-code-guide.
- El agente principal (parent) crea subagents (children), les delega tareas, recibe resultados resumidos, e integra todo en una respuesta coherente. Cada child tiene su propio context window aislado.
Si no estás listo:
Revisa primero:
- Módulo 04: El workflow agentic
- Módulo 06: Subagents
El mental model: Claude Code como hub de integraciones
De herramienta a plataforma
Hasta ahora has visto Claude Code como una herramienta que recibe instrucciones y ejecuta tareas. Con las integraciones, el modelo cambia:
┌─────────────────────────────────────────────────────────┐
│ CLAUDE CODE COMO HUB │
│ │
│ ┌───────────┐ │
│ │ Git repos │◀───┐ │
│ └───────────┘ │ │
│ │ │
│ ┌──────────┐ ┌────────────────┐ ┌──────────┐ │
│ │ SDK apps │───▶│ Claude Code │◀──│ MCP │ │
│ └──────────┘ │ (el hub) │ │ servers │ │
│ └────────────────┘ └──────────┘ │
│ ▲ ▲ │
│ │ │ │
│ ┌───────────┐ ┌──────────┐ │
│ │ CI/CD │ │ Remote │ │
│ │ pipelines │ │ Control │ │
│ └───────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────┘
Claude Code no solo ejecuta código — coordina entre múltiples sistemas. Puede leer un diff de Git, generar un PR description, ejecutar tests en CI, conectarse a una base de datos vía MCP, y recibir aprobación desde tu móvil via Remote Control. Todo desde la misma sesión.
La analogía del desarrollador
Piensa en cómo trabaja un developer senior en un equipo:
| Actividad del developer | Equivalente en Claude Code |
|---|---|
| Hace commits y PRs | Git workflows (cápsula 02) |
| Escribe scripts de automatización | SDK Python/TS (cápsula 03) |
| Configura CI/CD pipelines | Headless CLI (cápsula 04) |
| Se conecta a APIs y bases de datos | MCP servers (cápsula 05) |
| Revisa notificaciones desde el móvil | Remote Control (cápsula 05) |
Un developer no solo escribe código — integra su trabajo con sistemas de versionado, automatización, y comunicación. Claude Code hace exactamente lo mismo, y este módulo te enseña cómo.
Cómo se integra con lo que ya sabes
Integraciones y CLAUDE.md (Módulo 03)
Tu CLAUDE.md puede documentar las integraciones del proyecto:
# Git workflow
- Usamos conventional commits: feat:, fix:, docs:, test:
- PRs requieren al menos 1 reviewer
- Branch naming: feature/name, fix/name, docs/name
- Merge strategy: squash merge en main
# Automatización
- Pre-commit hook ejecuta lint con Claude Code headless
- CI/CD usa el SDK para code review automatizado
- MCP server de Postgres conectado para queries de debuggingIntegraciones y Hooks (Módulo 05)
Los hooks que aprendiste en el Módulo 05 son un punto de conexión natural:
- PreToolUse hook que valida operaciones de Git antes de ejecutarlas
- Stop hook que sugiere un commit al terminar una tarea
- PostToolUse hook que verifica el resultado de operaciones de Git
Integraciones y Subagents (Módulo 06)
Los subagents pueden usar las integraciones:
- Un General-purpose subagent que ejecuta comandos de Git en paralelo
- Un custom subagent que usa el SDK para batch processing
- Un Explore subagent que analiza el historial de Git
Un vistazo al módulo completo
Para que visualices cómo se integran los conceptos, aquí tienes un escenario real que usa las 4 dimensiones de integración:
La sesión sin integraciones
Tú: Hay un bug en el checkout. El usuario reporta que al
pagar con carrito vacío, la app crashea.
Claude Code (sin integraciones):
→ Lee el código de checkout (built-in)
→ Identifica el bug (no valida carrito vacío)
→ Corrige el código (built-in)
→ "Listo, el bug está corregido."
...pero no hay commit, no hay PR, no hay tracking.
Si cierras la terminal, ¿cómo sabes qué cambió?
¿Cómo lo revisas? ¿Cómo lo despliegas?
La misma sesión con integraciones
Tú: Hay un bug en el checkout. El issue #203 en GitHub tiene
los detalles. Investiga, corrige, y abre un PR.
Claude Code (con integraciones):
→ [MCP GitHub] Lee el issue #203: "Empty cart causes 500"
→ [MCP Postgres] Verifica: SELECT * FROM orders WHERE cart_items = '[]'
→ [Built-in] Lee el código, identifica el bug
→ [Built-in] Corrige el código, agrega test
→ [Git] git checkout -b fix/empty-cart-checkout
→ [Git] git commit -m "fix(checkout): validate empty cart before payment"
→ [Git] gh pr create --title "fix: validate empty cart" --body "Fixes #203"
PR #87 creado. Linked a issue #203. CI ejecuta tests.
[Remote Control] Recibes notificación en tu móvil:
"PR #87 creado. Tests passing. ¿Apruebas merge?"
La diferencia no es solo productividad — es que el trabajo queda registrado, revisable, y desplegable. Cada cambio tiene un commit, cada fix referencia un issue, y el flujo completo es reproducible.
El impacto práctico
Sin integraciones, Claude Code es un developer que trabaja en local y nunca hace push. Con integraciones, es un developer que sigue las prácticas del equipo: commits limpios, PRs con contexto, CI/CD automatizado, y trazabilidad completa.
Conceptos clave que verás
Terminal-native
Claude Code ejecuta Git, SDK scripts, y headless commands directamente en la terminal. No usa APIs web ni interfaces gráficas — todo pasa en el mismo entorno donde escribes código. Esto es una ventaja: si funciona en tu terminal, funciona en CI/CD.
Programmatic access
El SDK y el headless mode son dos formas de acceso programático, cada una con su nivel de complejidad:
Complejidad: Baja ────────────────────── Alta
Headless CLI (-p) SDK (Python/TS)
│ │
│ One-liner bash │ Script completo
│ Pipe Unix │ Async/await
│ Exit codes │ Try/catch
│ Texto o JSON │ Objetos tipados
MCP: el protocolo de extensión
MCP no es una herramienta — es un protocolo. Igual que HTTP permite que cualquier cliente hable con cualquier servidor web, MCP permite que cualquier agente de IA hable con cualquier fuente de datos. Claude Code es un MCP client, y hay decenas de MCP servers disponibles.
Automation spectrum
Las integraciones forman un espectro de automatización:
Manual ─────────────────────────────────────── Automático
Interactivo Headless CLI SDK CI/CD + SDK
(tú presente) (script bash) (programa) (sin humano)
Tú decides dónde colocarte en el espectro según la tarea, el riesgo, y la confianza.
Qué construirás en este módulo
A lo largo de las 5 cápsulas:
- Workflow de Git completo con commits semánticos, branches, y PRs
- Script con SDK que revisa código programáticamente
- Script headless que genera PR descriptions automáticamente
- Configuración MCP básica para conectar con datos externos
- Entender Remote Control y sus casos de uso
Al final del módulo, Claude Code estará conectado con tu infraestructura de desarrollo, no aislado en una terminal.
Versiones y compatibilidad
Este módulo cubre:
- Claude Code 2.0+
- Opus 5 (1M token context window)
- Sonnet 5 (1M token context window)
Features cubiertos:
- ✅ Git workflows nativos (commits, branches, PRs)
- ✅ SDK Python (
claude-agent-sdk) - ✅ SDK TypeScript (
@anthropic-ai/claude-agent-sdk) - ✅ Headless mode CLI (
-p,--output-format) - ✅ MCP server configuration
- ⚠️ Remote Control desde móvil (research preview, experimental)
Nota sobre cambios:
Git workflows y headless CLI son features estables — los conceptos no van a cambiar. El SDK tiene una API que puede evolucionar en detalles, pero la arquitectura es estable. MCP está en adopción activa y la configuración puede tener ajustes. Remote Control está en research preview y puede cambiar significativamente. Siempre consulta la documentación oficial para verificar la sintaxis actual.
Conexión con el proyecto integrador
En el Módulo 08, construirás una herramienta CLI completa con Claude Code. Las integraciones de este módulo serán parte del workflow:
- Git workflows para versionar tu proyecto con commits semánticos
- Headless CLI para automatizar validaciones del proyecto
- SDK (opcional) para crear scripts de testing automatizado
- MCP (opcional) para conectar tu herramienta con datos externos
Dominar las integraciones no solo mejora tu proyecto — te prepara para workflows profesionales donde Claude Code es un componente más de tu pipeline de desarrollo.
Resumen
Lo que aprendiste en esta cápsula:
- Las integraciones transforman Claude Code de herramienta interactiva a componente programable
- Hay 4 dimensiones de integración: Git, SDK, Headless CLI, MCP + Remote Control
- Cada dimensión resuelve un problema distinto: versionado, acceso programático, automatización, conexión externa
- Las integraciones se complementan con CLAUDE.md, hooks, y subagents de módulos anteriores
- Este módulo es el puente entre "usar Claude Code" y "integrar Claude Code en tu stack"
Siguiente cápsula: 02 - Git workflows — cómo Claude Code trabaja con Git para commits, branches, PRs, y code review.
Recursos adicionales
Documentación oficial
- Git Integration — Uso de Git con Claude Code
- SDK Documentation — SDKs de Python y TypeScript
- CLI Reference — Flags y opciones de CLI incluyendo headless mode
- MCP Setup — Configuración de MCP servers
Integraciones
- GitHub Actions — Claude Code en pipelines de CI/CD
- Headless Mode — Ejecución no interactiva
- Best Practices — Workflows recomendados para integraciones