Refactorizar con agentes: la receta de Google y un CI rápido

En 2010, Google refactorizó C++ en cerca de 250 millones de líneas sin IA. Su receta, por qué un CI lento frena a los agentes y qué me llevo para SDD.

Refactorizar con agentes empieza antes del agente

Cuando alguien me pregunta cómo refactorizar con agentes un código grande, la tentación es hablar del modelo, del prompt o de la herramienta. He escuchado el episodio de The Pragmatic Engineer con Titus Winters, autor principal de “Software Engineering at Google”, y me ha recordado que la parte difícil se resolvió hace más de quince años, sin ningún LLM de por medio.

Y casi a la vez, Vercel ha anunciado un CI pensado para el ritmo al que abren pull requests los agentes. Las dos cosas encajan mejor de lo que parece.

La receta de Google, en siete pasos

En 2010, Google tenía cerca de 250 millones de líneas de C++ que tocaban unos 10.000 ingenieros. Un equipo de una docena de personas se puso a limpiar código antiguo, parte escrito por los primeros empleados. Winters lo resume con una imagen que me encanta: era como cambiar los cimientos del Empire State sin cerrar el edificio ni cortar el tráfico, y encima encontrarse residuos nucleares en el sótano.

Según el resumen del episodio, lo hicieron así:

  1. Parsear: un MapReduce recorría todo el código y convertía cada target de build en un árbol de sintaxis abstracta.
  2. Encontrar patrones: buscaban en ese árbol las llamadas exactas que había que cambiar.
  3. Generar los cambios: los edits los escribía la máquina, no las personas.
  4. Hacer convivir lo viejo y lo nuevo: la API antigua y la nueva funcionaban a la vez.
  5. Repartir: con la API nueva lista, dividían los cambios por directorio y los enviaban por tandas.
  6. Bloquear lo viejo: se aseguraban de que nadie volviera a copiar el patrón antiguo.
  7. Borrar: al final, eliminaban la API vieja.

Como curiosidad, clang-format existe porque Winters y su equipo lo necesitaban para este refactor.

Lo que me llama la atención es que casi ninguno de esos pasos depende de quién escribe el cambio. Si mañana el paso 3 lo hace un agente en lugar de un generador basado en el AST, los pasos 4 a 7 siguen siendo igual de necesarios. Un agente sin ese marco te puede dejar media base de código migrada, la otra media no, y a alguien copiando el patrón viejo en un fichero nuevo esa misma tarde.

Los tests llegaron por necesidad

El otro dato del episodio que me quedo es de dónde salen los tests obligatorios en Google. Hacia 2007, Search ya no podía publicar cada mes y lo mejor que conseguía era sacar versiones trimestrales. Casi cualquier cambio en Google, incluso uno de Gmail, tocaba código de Search. Así que Google exigió que cada cambio llevara su test, y con el tiempo Search recuperó el ritmo.

Winters lo dice de una forma que suscribo: el miedo no es una base aceptable para hacer ingeniería. Si no puedes hacer un cambio valioso con seguridad, tu código no es sostenible.

Con agentes esto pesa todavía más. Winters cuenta que, hablando con ingenieros de otras empresas, le describen el mismo panorama: mucho más código que hace un año, alrededor de un 30% más de caídas (outages) en producción y el mismo número de funcionalidades. Es lo que le cuentan, no un estudio, pero me cuadra con lo que veo. Y aun así es optimista: cree que el valor de la IA no está en hacer lo mismo más rápido, sino en atreverse con proyectos que antes no tenían sentido por ambiciosos. Una migración como la de 2010, por ejemplo.

Lo conté en el post sobre vibe coding y SDD: el agente tropieza cuando nadie ha escrito las reglas. En una migración, las reglas son esos siete pasos y una batería de tests que te avise antes que tus usuarios.

Cuando el cuello de botella es el CI

Ahora la otra mitad. Si un agente reparte una migración en decenas de pull requests pequeños, cada uno espera al CI antes de que alguien lo revise. Vercel lo plantea así al presentar Vercel CI, en beta desde el 28 de octubre para todos los planes: la mayoría de sistemas de CI ejecutan el flujo entero en cada push, aunque cambies una línea, y cuanto más empujan tus agentes, más tiempo pasas esperando.

Su propuesta es ejecutar solo las tareas afectadas por el cambio y levantar solo el cómputo que esas comprobaciones necesitan. Se apoya en Turborepo: lee el turbo.json, marcas las tareas con la etiqueta ci y las que no han cambiado salen de la caché. El resto corre cada una en su máquina en cuanto terminan sus dependencias. El resultado lo publica como un check en el pull request de GitHub, así que las reglas de protección de rama siguen funcionando igual.

La cifra que dan es interna: en sus propios repositorios, el proceso de git push a “CI passed” es de 2 a 6 veces más rápido que antes. Dicen también que ya ha completado casi 8 millones de tareas entre sus repositorios y la beta privada. No lo he probado, así que me quedo con la idea más que con el producto.

Lo que me llevo

En onext trabajamos con Bitbucket, y ya expliqué cómo dejamos a los agentes trabajar en Bitbucket Pipelines con permisos escritos en el propio repo. Vercel CI, tal como lo describen, publica sus checks en GitHub, así que no es algo que vaya a enchufar mañana. Pero el principio me sirve igual, y lo junto con la receta de Google:

  • Escribe la migración como una spec antes de lanzar al agente. Qué patrón se busca, cómo conviven la API vieja y la nueva, en qué tandas se reparte y cuándo se borra lo antiguo.
  • Bloquea el patrón viejo desde el primer día. Un lint o un check que falle si alguien, persona o agente, vuelve a introducirlo.
  • Sin tests no hay migración. Si un cambio no viene con su test, no se mergea, igual que hizo Google cuando Search se atascó.
  • Mide el tiempo hasta el CI en verde. Si cada pull request espera veinte minutos, tus agentes trabajan a la velocidad de tu pipeline. Ejecutar solo lo afectado y cachear el resto es la primera palanca que miraría.
  • Revisa por directorio y por tandas. Pull requests pequeños y acotados se revisan mejor, y si algo sale mal, se deshacen mejor.

Refactorizar sin miedo

Me quedo con la frase de Winters sobre el miedo. Refactorizar con agentes no consiste en que el agente sea muy bueno, sino en montar las redes que te permiten cambiar mucho código sin miedo: una spec clara, tests obligatorios, el patrón viejo bloqueado y un CI que no te haga esperar.

En onext ayudamos a equipos a adoptar agentes de IA y a trabajar con Spec-Driven Development, y preparar el terreno para migraciones grandes es parte de nuestro trabajo. Si tienes una pendiente desde hace años y estás pensando en dársela a un agente, escríbenos y la planteamos juntos.

Fuentes

  1. Software engineering at Google & CS education with Titus Winters (se abre en una pestaña nueva)
  2. Introducing Vercel CI (se abre en una pestaña nueva)

Etiquetas

Más artículos de Spec-Driven Development