La IA trabaja en paralelo. Tu también deberías

Como ya vengo mencionando en mis últimas entradas, y como es de notable conocimiento, la manera en la que desarrollamos software está cambiando rápido gracias a la IA.

De a poco nos acostumbramos a pedirle ayuda para escribir funciones, corregir errores o generar tests. Poco a poco empezamos a darle más contexto, mejores prompts, archivos completos, reglas del proyecto. Y ahora, con enfoques como Spec Driven Development, la relación ya no se limita a solo pedir código, le asignamos una tarea y esperamos que realice todo flujo de análisis, desarrollo y pruebas.

El problema es que ese flujo no siempre es inmediato.

La IA analiza, planifica, genera tareas, implementa, corre tests, falla, corrige, vuelve a correr tests. Y mientras tanto nosotros nos quedamos mirando la terminal, chequeando redes sociales, preparándonos un café y viendo cuál nuevo modelo disruptivo ha salido esta semana que promete superar al resto, etc. Sin importar qué sea, estamos esperando que termine un ticket para recién poder pasar al siguiente.

Pero si la IA puede trabajar en paralelo, quizás nosotros también deberíamos adaptar nuestro flujo para acompañar esa velocidad.

Y ahí aparece un comando bastante simple, pero muy útil: git worktree.

El problema de trabajar con una sola carpeta

Durante años, la forma normal de trabajar con Git fue movernos entre ramas dentro del mismo directorio.

git checkout feature/login

Trabajamos en esa rama, hacemos cambios, commiteamos, abrimos un Pull Request y después pasamos a otra cosa.

El problema cuando estamos trabajando con IA, es que le damos un ticket a un agente. Este empieza a trabajar, pero mientras genera la especificación, el plan, las tareas, las implementa, comprueba que todo funciona, o si está corrigiendo errores. La mayor parte del tiempo no se requiere de una interacción nuestra.

Mientras tanto aparece otro ticket pequeño, o simplemente tenemos otra tarea que no depende de la anterior. Nos sentimos bloqueados, y quizás muchos de nosotros optamos por clonar en un directorio nuevo el proyecto e ir atacando en paralelo dos desarrollos. Pero hay un comando que puede solucionarnos esto.

Qué hace git worktree

git worktree permite tener varias carpetas de trabajo del mismo repositorio, cada una en una rama distinta.

Por ejemplo:

git worktree add ../app-login feature/login
git worktree add ../app-payment fix/payment-timeout

Con eso podríamos tener algo así:

app/          # main
app-login/    # feature/login
app-payment/  # fix/payment-timeout

Cada carpeta tiene su propia rama, sus propios archivos y su propio estado de trabajo. No hace falta cambiar de rama todo el tiempo. No hace falta hacer stash. No hace falta interrumpir lo que está haciendo un agente para empezar otra cosa.

Por qué esto encaja tan bien con SDD

En Spec Driven Development solemos trabajar por etapas.

Primero definimos qué queremos construir. Después aclaramos ambigüedades. Luego generamos un plan, lo dividimos en tareas y recién al final dejamos que la IA implemente.

Ese proceso es mucho más ordenado que simplemente pedirle “hazme esta feature”. Pero también puede tomar tiempo.

Y ese tiempo no siempre requiere nuestra atención completa.

Podemos tener una IA ejecutando el /implement de una feature mientras nosotros revisamos la especificación de otra. O podemos tener dos tickets en paralelo, cada uno en su rama, cada uno en su carpeta, cada uno con su propio contexto.

No se trata de abrir diez cosas a la vez y convertir el trabajo en caos. Se trata de dejar de pensar que estamos obligados a esperar que termine un ticket para recién empezar el siguiente.

Un ejemplo simple

Supongamos que tenemos dos tickets:

• agregar validaciones al login;
• corregir un timeout en pagos.

Podríamos crear dos worktrees:

git worktree add ../app-login-validation feature/login-validation
git worktree add ../app-payment-timeout fix/payment-timeout

Ahora podemos abrir cada carpeta en una ventana distinta del editor. En una carpeta, el agente trabaja sobre la validación del login. En otra, podemos revisar el bug de pagos o preparar la especificación para que otro agente lo tome.

Cada ticket vive en su propia rama.

Cada contexto queda separado.

Y eso, cuando trabajamos con IA, vale mucho.

Cuidado con confundir paralelismo con desorden

Esto no significa que ahora tengamos que trabajar en cinco tickets al mismo tiempo. Abrir demasiados frentes sigue siendo una mala idea. Con IA o sin IA.

La diferencia es que antes muchas veces estábamos bloqueados por la velocidad humana de implementación. Hoy empezamos a estar bloqueados por nuestra capacidad de organizar, revisar y decidir.

Entonces el problema ya no es solamente “cómo escribo más código”. El problema empieza a ser “cómo ordeno mejor el trabajo que la IA puede ejecutar”.

Y en ese escenario, herramientas como git worktree empiezan a tener otro valor.

Conclusión

La IA no solo cambia la forma en que escribimos código. También cambia la forma en que organizamos el trabajo alrededor del código.

Si usamos SDD para dividir mejor las tareas, definir mejor el contexto y darle instrucciones más claras a los agentes, tiene sentido que también adaptemos nuestro flujo de Git para trabajar con varios contextos en paralelo.

git worktree no es una herramienta nueva. Pero en esta etapa se vuelve especialmente útil.

Porque cuando la IA puede avanzar en un ticket mientras nosotros pensamos el siguiente, esperar mirando la terminal empieza a parecer más una costumbre que una necesidad.

La IA ejecuta en paralelo. Nosotros coordinamos en paralelo.