Claude Code: automatiza tareas con delegación inteligente

Claude Code es más que un editor: es tu herramienta para automatizar procesos, delegar tareas repetitivas y construir workflows que ejecutan código en tu infraestructura. En el contexto de la certificación Developer, necesitas entender cómo Claude Code se integra en tu stack de desarrollo y cuándo usarlo para resolver problemas reales.

Esta lección te muestra cómo convertir instrucciones en workflows automatizados, coordinar subagentes, gestionar permisos de forma segura y conectar todo a tu pipeline CI/CD.

Qué es Claude Code y por qué importa

Claude Code es la capacidad de Claude para analizar, escribir, modificar y ejecutar código en tu entorno. No es solo "generar código": es ejecutarlo, probarlo, iterar sobre errores y completar tareas de forma autónoma dentro de límites que tú defines.

Desde la perspectiva del desarrollador certificado:

Automatización sin infraestructura custom: No necesitas construir un orquestador personalizado; Claude Code + MCP y tool use ya lo hacen.
Delegación de tareas deterministas: Scripts de data processing, validación de código, generación de reportes, refactorización.
Integración en pipelines reales: Funcionan en CI/CD, post-procesamiento, auditoría.
Control de permisos granular: Defines exactamente qué puede hacer Claude: leer archivos específicos, ejecutar comandos limitados, acceder a recursos.

La diferencia con «dame código para copiar» es que Claude Code ejecuta y valida en tiempo real, permitiéndote usar Claude como un agente dentro de tu workflow automatizado.

Workflows con Claude Code: arquitectura y patrones

Un workflow con Claude Code responde a este patrón:

Trigger (evento, comando, schedule)
  ↓
Claude recibe contexto (archivos, estado, instrucciones)
  ↓
Claude analiza y propone acciones (o las ejecuta)
  ↓
Claude Code ejecuta con permisos limitados
  ↓
Resultado se valida y se reporta
  ↓
Proxima tarea o fin

Ejemplo real: validación de PR automática

Un desarrollador quiere que Claude revise PRs en busca de:

Importaciones no usadas
Secretos hardcodeados
Test coverage < 80%
Dependencias obsoletas

En lugar de escribir scripts manuales para cada paso, configura:

Trigger: GitHub Action al abrir PR
Contexto: diff del código, archivos afectados, configuración de linting
Instrucción a Claude: «Revisa el código, ejecuta validaciones, reporta en formato JSON»
Permisos: lectura de archivos del repo, ejecución de eslint, pytest, pip check — nada más
Resultado: comentario automático en el PR

Esta tarea, sin Claude Code, requeriría scripts bash complejos y mantenimiento constante. Con Claude Code, la lógica está centralizada y es reutilizable.

Subagentes y coordinación

En workflows complejos, no es suficiente un único Claude. Usas subagentes: instancias de Claude (o llamadas independientes) coordinadas por un agente orquestador.

Caso: pipeline de procesamiento de datos

Tienes un dataset de 10GB que necesita:

Limpieza y normalización
Validación de esquema
Generación de reportes estadísticos
Carga a data warehouse

En lugar de un único prompt monolítico, diseñas:

Agente 1 (Limpiador): Recibe chunk de datos, ejecuta transformaciones, valida salida
Agente 2 (Validador): Recibe datos limpios, comprueba esquema, reporta anomalías
Agente 3 (Analista): Genera stats, visualizaciones, detecta outliers
Agente Orquestador: Coordina el flujo, maneja errores, reintenta si es necesario

Cada subagente:

Recibe un contexto limitado (solo su parte del problema)
Usa MCP para acceder a recursos compartidos (archivos temp, DB de validación)
Reporta resultados en formato estructurado
Puede fallar sin romper todo el pipeline

La coordinación se logra a través de tool use (el orquestador llama a herramientas que invocan subagentes) o MCP prompts (templates predefinidos que el orquestador instancia).

Hooks: integración en tu stack

Hooks son puntos de integración entre Claude Code y tu infraestructura. No son código de Claude, sino definiciones de dónde y cómo ejecutar.

Tipos de hooks relevantes para el examen:

Git Hooks (pre-commit, post-push)
- Desencadenan Claude Code antes de que el código entre en el repo
- Validan mensajes de commit, formateo, security checks
- Evitan deuda técnica en origen
CI/CD Hooks (GitHub Actions, GitLab CI, Jenkins)
- Claude Code se ejecuta como parte del pipeline
- Accede a variables de entorno, secretos (con permisos limitados)
- Genera reportes, logs, y bloquea merges si es necesario
Webhook Hooks (eventos externos)
- Stripe invoice creada → Claude genera factura con formato
- Slack command → Claude ejecuta consulta y responde
- Calendar event → Claude prepara agenda, busca documentos relacionados

Implementación segura de hooks:

Evento desencadena llamada a API (ej: OpenAI Realtime o Anthropic Messages API)
  ↓
Se envía contexto con limpieza (sin secretos en claro)
  ↓
Claude responde con acciones propuestas (no directamente ejecuta)
  ↓
Tu código valida respuesta y ejecuta solo acciones permitidas
  ↓
Resultado se registra y audita

Nunca delegues ejecución directa de comandos peligrosos (rm -rf, drop database, etc.) a Claude sin validación intermedia.

Integración en CI/CD: pasos prácticos

Supongamos una cadena de CI/CD estándar (push → test → build → deploy).

Dónde cabe Claude Code:

Etapa	Tarea	Cómo se integra
Pre-commit	Linting, formateo	Git hook que invoca API de Claude
Test	Análisis de cobertura, sugerencias	Claude Code ejecuta `coverage.py`, analiza gaps
Build	Verificación de dependencias, seguridad	Claude audita package.json, requirements.txt, busca vulnerabilidades conocidas
Deploy	Validación de config, changelog	Claude genera release notes, valida env vars en staging
Post-deploy	Smoke tests, monitores	Claude ejecuta tests básicos, reporta health

Ejemplo YAML (GitHub Actions):

name: Claude Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Call Claude via API
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          python script_que_invoca_claude.py \
            --files $(git diff --name-only origin/main) \
            --format json
      - name: Comment on PR
        run: python post_comment.py

El script Python:

Recopila contexto (diff, archivos afectados)
Llama a Claude API con instrucciones específicas
Recibe respuesta estructurada
Valida y actúa (comenta, bloquea, etc.)

Permisos y seguridad: delega sin riesgos

Claude Code es potente pero debe estar acotado. El principio es least privilege.

Qué SÍ puedes permitir:

Lectura de archivos en directorio específico
Ejecución de binarios permitidos (eslint, pytest, black, etc.)
Escritura en directorios temporales
Llamadas a APIs públicas (con rate limiting)
Consultas de solo lectura a bases de datos

Qué NO:

Acceso a secretos, API keys, tokens (excepto si es necesario y auditado)
Comandos de shell sin validación (no subprocess.run() directo)
Escritura en archivos de producción sin aprobación
Eliminación de datos (incluso en staging)
Escalada de privilegios

Implementación segura:

# ❌ INSEGURO
os.system(f"npm install {package_name}")  # Inyección posible

# ✅ SEGURO
allowed_packages = ["lodash", "axios", "moment"]  # Whitelist
if package_name in allowed_packages:
    subprocess.run(["npm", "install", package_name], check=True)
else:
    raise ValueError(f"Paquete {package_name} no permitido")

En el contexto de MCP + Claude Code:

Define recursos en tu servidor MCP que expongan solo lectura
Define herramientas que ejecutan acciones permitidas
Claude Code usa esas herramientas, no comandos directos
Audita todas las ejecuciones

Para el examen

La certificación Developer valida tu capacidad para:

Diseñar workflows que deleguen tareas reales a Claude Code, sabiendo cuándo es apropiado y cuándo no.
Coordinar subagentes usando tool use y MCP para dividir problemas complejos.
Integrar en CI/CD de forma segura: dónde encaja Claude, cómo se invoca, cómo se valida la salida.
Aplicar permisos granulares de forma que Claude Code no pueda causar daño incluso si genera instrucciones inesperadas.
Reconocer patrones de error y recuperación: cómo estructurar workflows para que un fallo en un subagente no rompa el pipeline.
Usar MCP + Claude Code juntos: Claude Code ejecuta localmente, MCP conecta a recursos externos; ambos coordinados por el agente orquestador.

En el examen, espera preguntas tipo:

«¿Cuál es el patrón seguro para permitir a Claude Code escribir en un archivo?»
«Un workflow falla en el paso 2 de 4. ¿Cómo lo estructurarías para reintentarlo?»
«¿Cuándo es más apropiado usar un subagente que una única llamada a Claude?»
Escenarios donde necesitas elegir entre tool use, MCP, o Claude Code ejecutando directamente.

Para recordar

Claude Code ejecuta código en tu entorno bajo permisos limitados: no es solo generación, es automatización real dentro de límites que defines.
Los workflows usan subagentes coordinados: divide problemas complejos en agentes pequeños, cada uno con un contexto limitado y responsabilidad clara.
La integración en CI/CD requiere validación intermedia: Claude genera acciones, tu código valida y ejecuta solo lo permitido.
Seguridad = least privilege + auditoría: whitelist de comandos, lectura restringida a directorios específicos, y logs de todo lo que Claude Code intenta hacer.