La deuda de código que genera la IA no se paga. Se acumula en silencio.

Ya he defendido antes que el código barato es el código más caro. Esta es la versión más dura y más específica de esa afirmación, y ahora hay un número que la respalda: la deuda técnica generada por IA no se comporta como la deuda que sabemos gestionar. No se paga. Simplemente se apila en silencio en un lugar que nadie está mirando.

El número que debería preocuparte

Un estudio de 2026 de la Singapore Management University — «Debt Behind the AI Boom» — revisó 302,600 commits verificados escritos por IA en 6,299 repositorios y encontró 484,366 problemas distintos. La cifra que importa no es cuántos problemas introdujo la IA; es cuántos sobrevivieron: el 22.7% de los problemas que la IA introdujo seguían presentes en HEAD. Ni atrapados, ni arreglados, ni saldados — todavía ahí, vivos, en el código actual. Las tasas de introducción por herramienta iban del ~17% al ~29% según el asistente.

Casi una cuarta parte de los defectos, todavía en el árbol. Eso no es un problema de calidad de revisión. Es un tipo distinto de deuda.

Por qué la deuda de la IA se comporta diferente

La deuda técnica humana tiene un mecanismo natural de pago: alguien la escribió, así que alguien la recuerda. La persona que tomó el atajo lleva consigo un modelo mental de dónde están enterrados los cadáveres, siente el dolor cuando vuelve a ese módulo, y la salda porque es suya. Deuda y propiedad viajan juntas.

La deuda generada por IA corta ese vínculo. Nadie escribió el código, así que nadie es dueño del modelo mental de él. Se mergea con aspecto limpio — plausible, bien formateado, pasando los tests — y luego se queda ahí, sin que nadie lo sienta, porque no hay autor que lo sienta. Cuando el defecto por fin aflora, la respuesta no es «ah, claro, me acuerdo de esto». Es «¿quién escribió esto? …nadie». Ahora estás depurando un sistema que ningún humano llegó a entender, y el código alcanza su estado intocable, el de nadie-se-atreve-a-tocarlo, más rápido de lo que jamás lo haría uno escrito por humanos.

La deuda que generaste pero nunca entendiste no es un atajo que pagarás más tarde. Es un pasivo que ya está en el balance, en un idioma que nadie en el equipo habla.

La cobertura no es comprensión

El arreglo reflejo es «añade más tests». Pero los tests atrapan los fallos que anticipaste. La deuda de IA peligrosa es el código que pasa todos los tests y aun así está mal por razones que nadie entendió lo suficiente como para testear — el acoplamiento sutil, el caso límite que se traga, la suposición que se sostuvo hasta que dejó de hacerlo. La cobertura te dice que el código hace lo que dicen los tests. No te dice nada sobre si alguien sabe lo que el código hace.

La única cobertura real no tiene glamour:

• Mergea solo lo que alguien entiende. Si ningún humano del equipo puede explicar un diff y defenderlo, no está terminado — es un pasivo con un check verde puesto. La comprensión es el listón de aceptación, no que pasen los tests.
• Genera más pequeño, para que siga siendo legible. Un cambio de 40 líneas que un revisor lee de verdad le gana a uno de 400 líneas que ojea por encima. El volumen es la forma en que la deuda de IA se cuela sin leerse.
• Asigna la propiedad al mergear, no en el incidente. El nombre de alguien queda en él, y ese alguien puede explicarlo. Restaura el vínculo autor→deuda que la IA cortó.
• Trata «ya no entendemos este módulo» como un Sev-2. Ese es el estado real que hay que temer, y la IA te lleva ahí más rápido y más callado de lo que jamás lo hizo ningún equipo humano.

En resumen

La IA no solo abarató escribir código; abarató crear y olvidar deuda. Casi una cuarta parte de los problemas introducidos por IA siguen sentados en árboles de producción porque el mecanismo que solía saldar la deuda — un humano que recuerda — nunca estuvo en el bucle.

Deja de medir el código de IA por si pasa. Mídelo por si alguien lo entiende — porque la deuda que no puedes ver y de la que nadie es dueño es la única que de verdad se acumula.