Señales de deuda técnica en código generado con IA

Desarrollador revisando un pull request extenso en pantalla de ordenador

Un equipo nos escribió en octubre con una frase que resume bien el problema: «el producto funciona, pero ya nadie se atreve a tocarlo». Cuatro meses de desarrollo asistido. Dieciocho mil líneas. Cero documentación interna.

Lo revisamos. No estaba roto. Estaba hipotecado.

La deuda técnica en código generado con IA es el coste futuro que acumula un proyecto cuando el asistente resuelve cada petición de forma aislada, sin reutilizar lo que ya existe ni considerar la arquitectura completa. No produce errores inmediatos: produce un código base que funciona hoy y que mañana nadie sabe modificar sin romper algo.

Esa diferencia es la que casi nadie mide a tiempo. Y aquí va la parte incómoda: los asistentes no inventan este pasivo, lo vuelven invisible. Antes, escribir mal costaba tiempo y esa fricción delataba el problema. Ahora el volumen sale limpio, rápido y aparentemente razonable, así que las señales de deuda técnica en código generado con IA ya no duelen hasta que son caras.

Hemos auditado algo más de treinta proyectos construidos mayoritariamente con asistentes en los últimos dos años. El patrón se repite con una regularidad casi aburrida.

¿Qué síntomas aparecen antes de que el código empiece a fallar?

Las siete señales que aparecen antes de cualquier error son estas:

  • Duplicación que crece más rápido que el código base
  • Cambios que su propio autor no sabe explicar en voz alta
  • Tests que validan el comportamiento que el modelo ya decidió
  • Dependencias nuevas sin discusión previa en el changelog
  • Caída sostenida de las líneas movidas frente a las nuevas
  • Churn alto en código escrito el mismo mes
  • Tiempo creciente para entregar funcionalidades equivalentes

Ninguna de ellas se manifiesta como un error. Ahí está la trampa.

El pasivo acumulado no produce excepciones: produce lentitud organizativa. Tareas que antes llevaban dos horas pasan a llevar dos días. Nadie sabe decir exactamente cuándo empezó.

Duplicación que crece más rápido que el repositorio

Medimos esto primero porque es el marcador más barato de obtener. El informe de GitClear de 2026, que analiza volúmenes grandes de commits reales, documentó un crecimiento del 81% en código duplicado dentro de proyectos con alta adopción de asistentes. Nuestras cifras internas apuntan en la misma dirección: en los casos sanos la proporción se mueve en torno al 3-7%, mientras que en los asistidos sin revisión estricta ronda el 19%.

¿Qué significa en la práctica? Que la misma función de validación de email vive en cinco archivos con cinco implementaciones ligeramente distintas. Cuando cambia el requisito, arreglas tres. Las otras dos siguen ahí, esperando.

Pull requests que nadie es capaz de explicar en voz alta

Esta es nuestra prueba favorita y no requiere ninguna herramienta. Pides al autor que explique el cambio sin leer el diff. Si tarda más de noventa segundos en arrancar, el fragmento no se ha diseñado: se ha aceptado.

En una auditoría de abril aplicamos el método sobre dos docenas de cambios ya aprobados del trimestre anterior. Casi la mitad no pudieron explicarse. Y de esos, la mayoría contenía al menos una decisión arquitectónica relevante que el equipo desconocía haber tomado.

Total, que la revisión existía sobre el papel. Pero aprobar y entender habían dejado de ser la misma cosa hace tiempo.

Tests que pasan siempre porque validan lo que el asistente decidió validar

Cobertura del 84%. Suena bien. Hasta que lees las aserciones.

El patrón es casi cómico: el modelo escribe la función, después escribe la prueba de esa función, y la prueba comprueba exactamente el comportamiento que la función ya tiene, incluidos sus errores. Es un espejo, no una red de seguridad. En uno de los casos que analizamos mutamos de forma aleatoria cuarenta líneas de lógica de negocio y la suite siguió en verde en algo más de la mitad. (Enseñar ese resultado en la retro fue uno de los silencios más largos que recuerdo.)

Dependencias nuevas sin justificación en el changelog

Mira el package.json y cuenta. Si han entrado paquetes que nadie recuerda haber discutido, tienes un indicio sólido.

El generador resuelve problemas trayendo librerías. Es más rápido que escribir veinte líneas. El problema llega a los ocho meses, cuando varias de esas dependencias están sin mantenimiento y una arrastra una vulnerabilidad crítica que obliga a reescribir el módulo entero. Hemos visto proyectos de nueve semanas con más de sesenta dependencias directas donde la mitad habría bastado.

Y el coste no es teórico. Innowise documentó dos casos que ilustran bien la factura: un script de migración generado con ChatGPT que descartaba datos de clientes en silencio, con treinta horas de ingeniería para repararlo, y un cliente de API sin control de límites de peticiones que tumbó producción y se llevó otras veintiséis. Nadie revisó ninguno de los dos antes de integrarlos.

¿Por qué el asistente copia en lugar de reutilizar?

No es incompetencia del modelo. Es su diseño funcionando exactamente como se espera.

La ventana de contexto no ve tu arquitectura completa

Cuando pides una función de exportación a CSV, la herramienta ve el archivo abierto y quizá dos o tres más. No ve el módulo utils/formatters donde ya existe lo que necesita.

Nuestro cálculo aproximado: en un proyecto de 20.000 líneas, un asistente con 200.000 tokens de contexto podría abarcar la base de software en bruto, pero rara vez la recibe entera porque la indexación prioriza proximidad, no relevancia arquitectónica. Resultado: reinventa.

Creíamos al principio que esto se arreglaba con mejores instrucciones en el archivo de reglas del proyecto. Lo probamos durante seis semanas con dos equipos. La duplicación bajó unos cinco puntos, lo cual está bien, pero no resolvió nada estructural. Lo que sí funcionó fue otra cosa, y la explicamos más abajo.

El incentivo del modelo es cerrar el prompt, no reducir el acoplamiento

Un desarrollador sénior que detecta tres sitios donde podría abstraer, abstrae. Y carga con el coste de mantener esa abstracción durante dos años.

El asistente no tiene horizonte temporal. Su objetivo termina cuando el fragmento compila y responde a lo que le pediste. Es un optimizador local brillante, y el acoplamiento es, por definición, un problema global. No hay prompt que convierta lo uno en lo otro.

Cables entrelazados sin etiquetar en un rack como metáfora del acoplamiento

Cómo separar un problema real de una falsa alarma

Aquí es donde muchos equipos se pasan de frenada. Detectan duplicación, entran en pánico y paran dos sprints para refactorizar algo que iban a tirar en marzo.

No todo lo que parece pasivo lo es. Y parte de lo que lo es, no importa.

Indicadores que importan: ratio de refactorización, líneas movidas y churn a 30 días

El churn es el que más nos dice. Mide cuántas líneas escritas en los últimos treinta días han sido reescritas o eliminadas en ese mismo periodo.

El segundo indicador, líneas movidas frente a líneas nuevas, delata si el equipo está reorganizando o solo apilando. GitClear registró una caída de esta proporción del 21% al 3,8% en el conjunto de su muestra, que es exactamente lo que vemos cuando nadie reordena nada. Esta es la tabla de umbrales que aplicamos, ordenada por coste de corrección de menor a mayor:

Señal Métrica que la delata Umbral de alarma
Cambios inexplicables Explicación oral en 90 segundos Cualquier fallo
Dependencias sin discutir Paquetes nuevos sin entrada en changelog Más de 2 por sprint
Duplicación Porcentaje de código duplicado Por encima del 12%
Falta de reorganización Líneas movidas / líneas nuevas Por debajo de 1 cada 20
Reescritura constante Churn a 30 días Más del 30% en 3 sprints
Tests tautológicos Supervivencia a mutación de lógica Más del 30% sobrevive
Pérdida de velocidad Horas por funcionalidad equivalente Más del doble en 6 meses

Una relación sana de líneas movidas ronda 1 por cada 6 nuevas. En los casos con más problemas que hemos tocado, esa proporción cae por debajo de 1 cada 40. En el proyecto de octubre que mencionábamos al principio, el churn a treinta días rondaba el 47%. Si quieres el detalle completo de la metodología con la que levantamos cada una de estas cifras sobre un proyecto real, nuestra auditoría técnica de software desglosa el procedimiento exacto y los umbrales que aplicamos según el tamaño del equipo, algo que conviene ajustar antes de sacar conclusiones precipitadas.

Casos en los que la copia rápida es una decisión correcta

Sí, existen. Y son más de los que el purismo admite.

Si el módulo tiene menos de tres meses de vida esperada, duplicar es más barato que abstraer. Si estás validando una hipótesis de producto que puede morir en dos semanas, la abstracción es trabajo desperdiciado. Lo peligroso no es la copia: es la copia sin fecha de caducidad escrita en alguna parte. Pedimos siempre un comentario con formato // TEMP hasta YYYY-MM-DD y una tarea asociada. Suena burocrático. Evita casi todos los sustos.

Protocolo de revisión antes del merge

Esto es lo que sí funcionó cuando los archivos de reglas del proyecto se quedaron cortos. Tres pasos, ninguna herramienta nueva, unos doce minutos extra por cambio enviado.

Lo implantamos primero con un equipo de cuatro personas en enero. A los dos meses el duplicado había caído de algo más del 20% a menos del 10% sin dedicar un solo sprint a saneamiento. El cambio no fue técnico, fue de proceso.

Trazar el origen del fragmento generado

Cada envío responde a una pregunta obligatoria en la plantilla: ¿qué partes de este cambio salieron del asistente y con qué instrucción?

No es para señalar a nadie. Es para que el revisor sepa dónde mirar con lupa. Un bloque escrito a mano y uno autocompletado requieren tipos de atención distintos, y fingir lo contrario es la forma más rápida de que entren decisiones silenciosas a la base de software.

Exigir la explicación oral antes de aprobar

Noventa segundos. Sin pantalla compartida. Que el autor cuente qué hace el cambio, por qué así y qué pasa si falla.

Habíamos probado antes con checklists escritos y no servían de nada: la gente los rellenaba en automático. La explicación hablada no se puede fingir. Si el autor no la tiene, aparece inmediatamente, y lo que sigue no es un rechazo sino una conversación de cinco minutos que normalmente mejora el diseño. (Al principio les parecía un control absurdo a todos. Al mes lo defendían ellos.)

Pruebas escritas por una persona distinta a quien lanzó el prompt

Esta regla rompe el espejo del que hablábamos antes, y conecta con la mitigación que más repiten los equipos que trabajan bien con asistentes: escribir primero la prueba, documentar después el contexto.

Quien no conoce la implementación escribe las aserciones desde el comportamiento esperado, no desde lo que ya existe. En el equipo de enero, aplicar esto hizo que la cobertura bajara del 84% al 71%. Bajó. Y la detección de regresiones en preproducción se duplicó con holgura, pasando de unas cinco incidencias interceptadas por trimestre a más de diez.

La cobertura es una métrica de vanidad cuando quien escribe las pruebas ya sabe la respuesta. Nos costó aceptarlo porque antes defendíamos lo contrario en nuestros propios informes. Esa comparativa de cifras, con la suite entera en verde y las regresiones colándose igual, la vimos repetida casi idéntica al revisar el análisis de qué hay que reescribir de una app de Bolt y qué código genera en productos que llegaron a nosotros con métricas aparentemente impecables, lo que confirma que el problema es de método y no de herramienta concreta.

Equipo de desarrollo discutiendo métricas de calidad frente a una pizarra

Qué medir cada sprint para que el problema no vuelva a crecer

Cuatro métricas ya son demasiadas. Nadie las mira. Nos quedamos con tres y las revisamos en la retro, cinco minutos, siempre al final.

Un panel mínimo de tres métricas

  • Churn a 30 días (alerta por encima del 30%)
  • Porcentaje de duplicado (alerta por encima del 12%)
  • Cambios aprobados sin explicación oral (alerta por encima de cero)

La tercera es binaria a propósito. No admite matices ni negociación, y por eso es la que más disciplina genera. Las dos primeras salen de cualquier analizador estático en menos de veinte minutos de configuración inicial.

Cómo justificar ante dirección las horas de saneamiento

No hables de calidad. Habla de velocidad de entrega.

El argumento que funciona es el diferencial de tiempo por funcionalidad equivalente. En el proyecto de octubre, una feature de complejidad media llevaba catorce horas en el mes tres y treinta y ocho en el mes siete. Mismo equipo, misma complejidad. Casi el triple de coste para el mismo resultado: eso es lo que entiende un comité de dirección, y es lo que convierte «refactorizar» en «recuperar veinticuatro horas por entrega».

Presentado así, aprobaron tres semanas de saneamiento sin discusión. Presentado como «tenemos duplicación», habrían dicho que no. Lo hemos visto fallar a partir de esa segunda formulación más veces de las que nos gustaría admitir, y es exactamente el mismo problema que aparece cuando toca abordar nuestro enfoque para escalar un MVP hecho con IA y nadie ha preparado el terreno con cifras traducidas a lenguaje de negocio antes de pedir presupuesto.

Panel de métricas de calidad de software con tres indicadores en pantalla

Preguntas frecuentes sobre calidad del código asistido

¿Cómo sé si mi proyecto ha acumulado deuda técnica?

Mira tres cosas antes que ninguna otra: el porcentaje de duplicado, el churn a treinta días y cuántos cambios se aprobaron el último mes sin que nadie pudiera explicarlos en voz alta. Si las tres están fuera de umbral a la vez, tienes pasivo acumulado. Si solo lo está una, probablemente sea ruido.

¿Cuánto tarda en notarse el problema en un proyecto nuevo?

Según nuestros registros, entre el mes cuatro y el mes siete. Antes de las 8.000 líneas casi nunca se percibe, porque todo sigue cabiendo en la cabeza de quien lo escribió. El punto de inflexión suele coincidir con la entrada de un segundo o tercer desarrollador.

¿Hay que dejar de usar asistentes entonces?

No. Los equipos con mejores números en nuestras auditorías usan generación automática de forma intensiva. La diferencia no está en la herramienta, está en el filtro de entrada. Sin revisión estricta, el volumen de salida amplifica cualquier defecto de proceso que ya tuvieras.

¿Puede la IA ayudar a reducir la deuda técnica?

Aquí hay un desacuerdo real que conviene nombrar. IBM y buena parte de la divulgación técnica sostienen que los modelos pueden refactorizar y sanear software automatizadamente. Los datos de repositorio de GitClear muestran lo contrario: más duplicación y menos reorganización. Nuestra lectura es que ambas cosas son ciertas en contextos distintos. Un modelo refactoriza bien un archivo cuando una persona le marca qué y por qué; genera pasivo cuando se le deja decidir sola a escala de proyecto. La variable no es el modelo, es quién define el alcance.

¿Hay que reescribir una aplicación programada con vibe coding?

Casi nunca entera. El vibe coding no genera deuda por sí mismo: la amplifica cuando la base de software ya la arrastraba. Lo que recomendamos es identificar los dos o tres módulos con peor churn y mayor duplicado, reescribir solo esos, y aplicar el protocolo de revisión al resto. Reescribir todo suele costar más que el problema que resuelve.

¿Qué herramienta recomendáis para medir el duplicado?

Cualquiera que ya tengas integrada. SonarQube, jscpd o el propio analizador de tu CI dan cifras suficientemente comparables para detectar tendencia. Lo importante no es la precisión absoluta del número, sino medirlo siempre igual y mirarlo cada sprint.

¿La explicación oral no ralentiza demasiado la entrega?

Unos doce minutos por cambio enviado. En el equipo de cuatro personas que lo implantó, eso supuso alrededor de dos horas semanales. El retorno fueron unas veinticuatro horas recuperadas por funcionalidad una vez estabilizado el proyecto. La cuenta sale sola.

Lo que de verdad hay que vigilar

Un proyecto con 15% de duplicado y cambios que todo el mundo entiende está sano. Uno con 6% y nadie capaz de explicar su propio software está en problemas serios. (Hemos auditado los dos. El segundo salió mucho más caro.)

Busca el síntoma combinado: duplicación al alza, churn alto y revisores que aprueban sin comprender. Cuando los tres coinciden durante tres sprints seguidos, no es una sospecha. Es una factura con fecha.

Founder & Software Engineer
Ingeniero de Software y Desarrollador Full Stack con más de 10 años de experiencia operativa. Dirige MVPtoSaaS aplicando los mismos estándares de fiabilidad y rendimiento exigidos en sistemas industriales y de alta criticidad. El enfoque de Felipe asegura que cada producto que transita por MVPtoSaaS cuente con código limpio, bases de datos optimizadas para alta concurrencia y despliegues automatizados preparados para el crecimiento sostenido sin deuda técnica.