Ejecucion en Paralelo — Multiples Agentes, Maxima Velocidad
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 tecnica: ejecucion en paralelo. En lugar de trabajar en una tarea a la vez, ejecutas multiples agentes de IA simultaneamente en tareas independientes.
Piensalo como la diferencia entre tener un asistente habil 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 continuas trabajando en tu sesion principal. Esta es la base de la ejecucion 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 sesion principal maneja una tarea completamente diferente.
Lanzando Multiples Agentes en Segundo Plano
Para maximo 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 simultaneamente. Cada agente tiene acceso completo al contexto del proyecto y puede leer y escribir archivos independientemente.
Aislamiento con Worktrees
Cuando agentes en paralelo podrian 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 esta 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 configuracion, layouts o modulos utilitarios.
Ejemplo Real: Dos Cursos en Paralelo
Asi se desarrollo la ejecucion en paralelo para crear dos cursos completos simultaneamente:
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 mas rapido que la creacion secuencial. La principal sobrecarga fueron los 10 minutos dedicados a revisar el output combinado.
Cuando Paralelizar
La paralelizacion funciona mejor cuando las tareas son verdaderamente independientes. Aqui hay un marco de decision:
Buenos Candidatos para Ejecucion en Paralelo
Creacion de archivos independientes:
- Diferentes lecciones en un curso
- Componentes separados que no se importan entre si
- Archivos de test para diferentes modulos
- Paginas de documentacion
Investigacion e implementacion simultaneamente:
# 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."
Cuando NO Paralelizar
Cambios dependientes: Si el Agente B necesita el output del Agente A, deben ejecutarse secuencialmente. Por ejemplo, crear una migracion 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 configuracion, uno sobrescribira al otro. Usa worktrees o ejecutalos secuencialmente.
Logica secuencial: Pasos que deben ocurrir en orden -- como construir, luego probar, luego desplegar -- no pueden paralelizarse.
El Patron Dispatcher
Para proyectos complejos, usa un patron dispatcher: una sesion 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 patron dispatcher es como escalas de creacion de archivos en paralelo a desarrollo de funcionalidades en paralelo. Piensas en grafos de dependencia y ejecutas ramas independientes simultaneamente.
Gestionando el Output en Paralelo
Ejecutar multiples agentes crea un cuello de botella de revision si no estas organizado. Aqui 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 revision 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 logicos:
# 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 pequeno e incrementa el paralelismo conforme te sientas comodo:
- Semana 1: Ejecuta un agente en segundo plano mientras trabajas en tu sesion principal. Acostumbrate a revisar output asincrono.
- Semana 2: Ejecuta dos agentes en segundo plano simultaneamente. Practica el patron dispatcher en proyectos pequenos.
- Semana 3: Usa worktrees para desarrollo de funcionalidades en paralelo. Coordina agentes en una tarea mas grande.
- Semana 4: Ejecucion en paralelo completa -- multiples agentes, worktrees y el patron 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.