Saltar al contenido
Lección 6 de 12

Ejecución en Paralelo — Múltiples Agentes, Máxima Velocidad

8 min read

El Mayor Desbloqueo de Productividad

Todo lo cubierto hasta ahora -- la mentalidad, el flujo de trabajo, el prompting -- te lleva a aproximadamente 3x de productividad. El salto de 3x a 5.7x viene de una técnica: ejecución en paralelo. En lugar de trabajar en una tarea a la vez, ejecutas múltiples agentes de IA simultáneamente en tareas independientes.

Piénsalo como la diferencia entre tener un asistente hábil y tener cuatro. Con un asistente, las tareas se ejecutan secuencialmente. Con cuatro, las tareas independientes se ejecutan al mismo tiempo. Tu trabajo cambia de hacer el trabajo a despachar y revisar trabajo.

Agentes en Segundo Plano

Claude Code soporta agentes en segundo plano que se ejecutan independientemente mientras continúas trabajando en tu sesión principal. Esta es la base de la ejecución en paralelo:

# Iniciar un agente en segundo plano para una tarea independiente
claude --background "Crea los 12 archivos de lecciones para el curso de
       RAG Engineering con contenido completo, frontmatter correcto
       y ejemplos de codigo"

# Continuar trabajando en tu sesion principal en otra cosa
claude "Mientras tanto, implementa el componente de navegacion del curso
       con enlaces de leccion anterior/siguiente y un indicador de progreso"

El agente en segundo plano trabaja independientemente, leyendo el contexto del proyecto, creando archivos y completando su tarea. Cuando termina, revisas el output. Mientras tanto, tu sesión principal maneja una tarea completamente diferente.

Lanzando Múltiples Agentes en Segundo Plano

Para máximo paralelismo, lanza varios agentes a la vez:

# Agente 1: Contenido en ingles
claude --background "Crea todos los archivos de lecciones en ingles
       (.en.mdx) para el curso de AI Productivity con contenido completo"

# Agente 2: Contenido en espanol
claude --background "Crea todos los archivos de lecciones en espanol
       (.es.mdx) para el curso de AI Productivity, traduciendo de
       las versiones en ingles"

# Agente 3: Trabajo de componentes
claude --background "Construye el componente CourseCard con miniatura,
       barra de progreso, conteo de lecciones y badge de dificultad"

# Sesion principal: Infraestructura
claude "Configura el enrutamiento de cursos y la generacion dinamica
       de paginas para /courses/[slug]/[lesson]"

Cuatro flujos de trabajo sucediendo simultáneamente. Cada agente tiene acceso completo al contexto del proyecto y puede leer y escribir archivos independientemente.

Aislamiento con Worktrees

Cuando agentes en paralelo podrían modificar los mismos archivos, usa git worktrees para aislar su trabajo:

# Crear worktrees aislados para trabajo en paralelo
claude --worktree "Refactoriza el sistema de autenticacion para usar JWT
       con refresh tokens"

# Esto crea un nuevo git worktree en .claude/worktrees/
# con su propia rama, para que los cambios no entren
# en conflicto con otros agentes o tu rama principal

Los worktrees dan a cada agente su propia copia del repositorio. Cuando el trabajo está hecho, revisas los cambios y los fusionas:

# Revisar lo que produjo el agente del worktree
git diff main..worktree-branch

# Fusionar si todo se ve bien
git merge worktree-branch

Esto es esencial para tareas que tocan archivos compartidos como configuración, layouts o módulos utilitarios.

Ejemplo Real: Dos Cursos en Paralelo

Así se desarrolló la ejecución en paralelo para crear dos cursos completos simultáneamente:

Configuracion de la sesion:
- Curso 1: RAG Engineering (14 lecciones, EN + ES = 28 archivos)
- Curso 2: LLM Fine-Tuning (12 lecciones, EN + ES = 24 archivos)
- Total: 52 archivos de contenido + 4 archivos meta = 56 archivos

Plan de ejecucion:
- Agente 1: Lecciones en ingles de RAG Engineering (14 archivos)
- Agente 2: Lecciones en espanol de RAG Engineering (14 archivos)
- Agente 3: Lecciones en ingles de LLM Fine-Tuning (12 archivos)
- Agente 4: Lecciones en espanol de LLM Fine-Tuning (12 archivos)
- Principal: Archivos meta e infraestructura de cursos (4 archivos + enrutamiento)

Tiempo: Todos los agentes completaron en 35 minutos
Estimacion secuencial: 3-4 horas

Resultado: 56 archivos de contenido listos para produccion creados en
paralelo, cada uno con frontmatter correcto, 800-1200 palabras de
contenido, ejemplos de codigo y formato consistente.

El enfoque en paralelo fue aproximadamente 5-6x más rápido que la creación secuencial. La principal sobrecarga fueron los 10 minutos dedicados a revisar el output combinado.

Cuándo Paralelizar

La paralelización funciona mejor cuando las tareas son verdaderamente independientes. Aquí hay un marco de decisión:

Buenos Candidatos para Ejecución en Paralelo

Creación de archivos independientes:

  • Diferentes lecciones en un curso
  • Componentes separados que no se importan entre sí
  • Archivos de test para diferentes módulos
  • Páginas de documentación

Investigación e implementación simultáneamente:

# Agente 1: Investigacion
claude --background "Investiga el mejor enfoque para implementar
       reconexion WebSocket con backoff exponencial. Resume las
       opciones y recomienda una."

# Agente 2: Implementacion de partes conocidas
claude "Mientras esa investigacion ocurre, implementa la configuracion
       de conexion WebSocket y el manejo de mensajes usando el patron
       que ya tenemos en el modulo de chat."

Testing y desarrollo en paralelo:

# Agente 1: Escribir tests para codigo existente
claude --background "Escribe tests comprensivos para todas las rutas
       de API en src/app/api/. Cubre casos de exito, casos de error
       y casos extremos. Usa los patrones de test existentes."

# Principal: Desarrollar nuevas funcionalidades
claude "Agrega la funcionalidad de preferencias de usuario mientras
       se escriben los tests para el codigo existente."

Cuándo NO Paralelizar

Cambios dependientes: Si el Agente B necesita el output del Agente A, deben ejecutarse secuencialmente. Por ejemplo, crear una migración de base de datos (Agente A) y luego construir una API que use el nuevo esquema (Agente B).

Modificaciones de estado compartido: Si dos agentes modifican el mismo archivo de configuración, uno sobrescribirá al otro. Usa worktrees o ejecútalos secuencialmente.

Lógica secuencial: Pasos que deben ocurrir en orden -- como construir, luego probar, luego desplegar -- no pueden paralelizarse.

El Patrón Dispatcher

Para proyectos complejos, usa un patrón dispatcher: una sesión principal coordina el trabajo mientras agentes en segundo plano lo ejecutan.

# La sesion principal actua como dispatcher
claude "Necesito agregar un sistema de notificaciones a la app.
       Divide esto en tareas independientes que puedan ejecutarse
       en paralelo."

# Claude responde con un desglose de tareas:
# Tarea 1: Esquema de base de datos y migracion (independiente)
# Tarea 2: Endpoints de API (depende de Tarea 1)
# Tarea 3: Componentes de UI (independiente de Tareas 1-2)
# Tarea 4: Configuracion de conexion en tiempo real (independiente)
# Tarea 5: Integracion y conexion (depende de todas las anteriores)

# Ejecutar tareas independientes en paralelo
claude --background "Tarea 1: Crea la migracion de tabla notifications
       con campos: id, user_id, type, title, message, read, created_at"

claude --background "Tarea 3: Construye el componente NotificationBell
       con panel desplegable, badge de no leidos y items de lista de
       notificaciones. Usa datos mock por ahora."

claude --background "Tarea 4: Configura la conexion WebSocket para
       entrega de notificaciones en tiempo real. Crea el hook y provider."

# Despues de que las Tareas 1, 3, 4 completen:
claude "Tarea 2: Construye los endpoints de API de notificaciones
       usando la migracion de la Tarea 1"

# Despues de que todas las tareas completen:
claude "Tarea 5: Conecta todo — conecta los componentes de UI a la
       API, enlaza el WebSocket para actualizaciones en tiempo real
       y reemplaza datos mock con llamadas reales a la API"

El patrón dispatcher es cómo escalas de creación de archivos en paralelo a desarrollo de funcionalidades en paralelo. Piensas en grafos de dependencia y ejecutas ramas independientes simultáneamente.

Gestionando el Output en Paralelo

Ejecutar múltiples agentes crea un cuello de botella de revisión si no estás organizado. Aquí hay estrategias para gestionar el output:

Revisar conforme los agentes completan: No esperes a que todos los agentes terminen. Revisa cada uno conforme completa. Esto escalona tu trabajo de revisión y captura problemas temprano.

Usa git status para rastrear cambios:

# Ver lo que cada agente ha creado o modificado
git status

# Revisar cambios por rutas especificas
git diff -- src/content/courses/rag-engineering/
git diff -- src/components/CourseCard.tsx

Haz commit en bloques lógicos:

# Haz commit del trabajo de cada agente por separado para historial limpio
git add src/content/courses/rag-engineering/*.en.mdx
git commit -m "feat: add RAG Engineering course English lessons"

git add src/content/courses/rag-engineering/*.es.mdx
git commit -m "feat: add RAG Engineering course Spanish lessons"

Maneja conflictos inmediatamente: Si dos agentes accidentalmente modifican el mismo archivo, resuelve el conflicto de inmediato antes de que se componga con cambios adicionales.

Escalando Tu Paralelismo

Empieza pequeño e incrementa el paralelismo conforme te sientas cómodo:

  1. Semana 1: Ejecuta un agente en segundo plano mientras trabajas en tu sesión principal. Acostúmbrate a revisar output asíncrono.
  2. Semana 2: Ejecuta dos agentes en segundo plano simultáneamente. Practica el patrón dispatcher en proyectos pequeños.
  3. Semana 3: Usa worktrees para desarrollo de funcionalidades en paralelo. Coordina agentes en una tarea más grande.
  4. Semana 4: Ejecución en paralelo completa -- múltiples agentes, worktrees y el patrón dispatcher trabajando juntos en un proyecto significativo.

La curva de aprendizaje no es sobre las herramientas. Es sobre desarrollar el modelo mental para pensar en paralelo -- identificar flujos de trabajo independientes, gestionar dependencias y revisar output eficientemente. Una vez que construyes esa habilidad, tienes acceso al multiplicador completo de 5.7x.