blog
Si borras el código, ¿qué te queda?
El software regenerativo consiste en tratar el código que escribe un agente como tratas un pod: cuando hay que cambiarlo, lo borras y lo generas otra vez. Chad Fowler lleva casi un año dándole vueltas a la idea, y el 11 de noviembre Žan Jonke presentó turri, una herramienta de código abierto que la pone en práctica. Solo funciona si lo que tiene que hacer tu sistema está escrito en algún sitio que no sea el código, y en un sistema con años casi nunca lo está.
Con los servidores ya pasó
Si llevas un cluster de Kubernetes, esto ya lo haces. Un pod que se porta raro no se arregla desde dentro: lo borras y el Deployment crea otro igual. Lo que importa es el manifiesto, y está en Git.
Antes les tocó a los servidores. En 2012 Martin Fowler describió el phoenix server, una máquina que se reconstruye desde cero cada cierto tiempo para que no acumule cambios que nadie dejó escritos. Un año después otro Fowler, Chad, entonces CTO de la empresa que hacía Wunderlist, defendió que un servidor no se parchea: se tira y se crea otro. Aquel artículo se titulaba «Trash Your Servers and Burn Your Code», y de él sale el nombre de infraestructura inmutable.
En diciembre de 2025 Chad Fowler abrió The Phoenix Architecture, una serie que ya va por 28 ensayos, para decir lo mismo del código. Escribir código era caro y por eso se conservaba. Ahora un agente lo escribe en minutos, y lo que escasea es entenderlo y comprobar que hace lo que debe. Retocar el código que ya tienes le parece lo mismo que entrar por SSH en un servidor de producción a cambiar un fichero de configuración, y su regla es no tocarlo si lo puedes regenerar.
Lo que solo está en el código
Para saber si puedes borrar el tuyo, Fowler propone pensar en un comando:
rm -rf src/
No hay que ejecutarlo. Basta con imaginar que ya lo has hecho y preguntarte con qué comprobarías que el código nuevo es correcto. Es su prueba del borrado. Si la respuesta sincera es «con el código viejo», ese código hace a la vez de especificación, de batería de tests, de documentación y de registro de errores.
Con un pod ni te lo planteas, porque la respuesta está en el manifiesto. Con un servicio que lleva años en producción, la respuesta está repartida por el código en forma de reintentos arbitrarios, validaciones raras y un timeout de 17 segundos que nadie sabe ya por qué son 17. El ejemplo es del propio Fowler, que en junio escribió que la implementación recuerda lo que la organización olvida. Todo eso parece basura, y muchas veces es la cicatriz de un incidente.
Joel Spolsky ya lo había dicho en 2000 a propósito de Netscape, que había reescrito su navegador desde cero y llevaba casi tres años sin sacar una versión importante. Lo feo del código viejo, eso que nadie sabe por qué está ahí, son errores que alguien arregló. Si regeneras un sistema así sin haber apuntado antes todos esos arreglos, se pierden. En un sistema heredado lo primero es sacarlos del código, y reescribir viene después.
Lo que tiene que quedar fuera
Para poder borrar el código tienen que existir fuera de él cuatro cosas: la especificación de lo que hace cada pieza, las evaluaciones que cualquier implementación tiene que pasar, los contratos con las piezas vecinas y el registro de qué versión de la especificación produjo cada código. Los datos van aparte y tampoco se regeneran. En Kubernetes borras el pod y el volumen persistente sigue donde estaba.
No sirve cualquier test. Uno unitario que llama a una función concreta desaparece con ella. Los que sobreviven prueban el sistema desde fuera, por lo que promete a quien lo usa: un saldo nunca queda en negativo, lo que se guarda se lee igual al recuperarlo. Si al reescribir tu servicio en otro lenguaje la batería de tests dejara de servir, esos tests están atados a la implementación. Escribir los buenos, reconoce Fowler, cuesta más que escribir el código que describen.
El que dejó de leer su código
Jonke es ingeniero en codeplain y presentó turri con una entrada en la que cuenta cómo llegó hasta ahí. Con un agente sacaba una funcionalidad por hora, cada una de varios miles de líneas. Como no le daba tiempo a revisarlas, dejó de leer el código y empezó a juzgar el programa por si hacía lo que tenía que hacer. Acabó respondiendo de un software que ya no entendía.
Lo que revisa ahora es un fichero en ∗∗∗plain, el lenguaje en el que codeplain escribe lo que debe hacer un programa. Una línea dice, por ejemplo, que todo clear quita de la lista las tareas hechas y qué imprime al acabar. Cuando cambia una línea, turri calcula a qué funcionalidades afecta y regenera solo ese código. La orden /regenerate borra el código entero y lo construye otra vez, así que la prueba del borrado deja de ser imaginaria. Si la versión nueva se comporta de otra manera, es que la primera vez el agente rellenó un hueco por su cuenta, y eso se arregla en la especificación.
La otra mitad de turri es desconfiar del agente. Jonke da por hecho que hará trampas: cambiará el test en lugar del código, o dirá que ha ejecutado algo que no ejecutó. En su empresa tienen un canal de Slack para guardar las excusas. En una, un agente explica que el fallo de la CI en Linux estaba en el test, que ya lo ha arreglado y que la batería completa pasa «en mi Mac». Por eso en turri las revisiones y los tests los lanza el programa que envuelve al agente, en controles que no dependen de él. «Un agente puede saltarse una frase de un prompt. No puede saltarse un control», escribe.
kubelatch hace lo mismo con un agente en un cluster. Si dejas activado «Las escrituras piden mi aprobación», cada cambio espera a que lo decidas tú, le hayan dicho al agente que pregunte o no, salvo que le hayas aprobado un rol temporal.
Dónde no llega
La interfaz de usuario es lo último que Fowler regeneraría, porque cada cambio le rompe la costumbre a quien la usa. Fowler pide además muchísimo cuidado con las primitivas criptográficas, los parsers de protocolos, el código donde el rendimiento es crítico y lo que está regulado o pone en riesgo a personas.
Tampoco está claro que escribir la especificación dé menos trabajo que leer el código. Birgitta Böckeler, de Thoughtworks, probó en 2025 tres herramientas de desarrollo guiado por especificación. Con una acabó prefiriendo revisar el código a revisar tantos ficheros de Markdown, y con otra la misma especificación no siempre le dio el mismo código.
turri hoy solo construye desde cero y no puede adoptar un proyecto que ya existe. Te obliga además a decir lo que quieres con la claridad suficiente para dejarlo escrito, y eso es trabajo.
La especificación, eso sí, no tiene por qué ir primero. En septiembre Fowler escribió que sus primeros intentos de especificar un sistema siempre salen mal. Prefiere programar hasta que algo funcione, escribir entonces lo aprendido y regenerar para ver qué se le había quedado fuera.
Por dónde empezar
No hace falta turri ni borrar nada. Elige un componente pequeño, uno que podrías reescribir en una tarde, y hazle la prueba del borrado sobre el papel: qué entra, qué sale, qué no puede pasar nunca y con qué lo comprobarías si mañana el código fuera otro. Lo que no sepas contestar es lo que hoy solo está en el código. Escríbelo como un test que pruebe el componente desde fuera, antes de dejar que un agente lo toque.
Si quieres verlo llevado hasta el final, turri es de código abierto, con licencia MIT.
Picaporte Labs es una sola persona, en España. Si has regenerado un servicio de verdad en lugar de mantenerlo, escríbeme y cuéntame qué se perdió por el camino.