¿Código más rápido, deuda más profunda? Lo que dice la ciencia sobre programar con IA

Hay una sensación nueva en el oficio, y seguro la reconoces: le pides una función a la IA, te la escribe entera en tres segundos, la pegas, compila, funciona a la primera, y por un momento sientes que vas volando. A mí me enganchó rapidísimo —cada tarea despachada en segundos da un golpecito de dopamina difícil de soltar—. El problema es que esa sensación, la de ir rápido, es justo la parte que la evidencia de este 2026 está poniendo en duda. Y ojo, no la velocidad de escribir código: esa es real y no hay discusión. Lo que está en duda es la velocidad de terminar el trabajo y, sobre todo, la factura que llega después.

En este artículo quiero separar la sensación de los datos. Voy a apoyarme en tres piezas de investigación seria —un ensayo controlado de METR, una revisión de 104 fuentes publicada en ACM TOSEM, y un panel de ICSE 2026— para responder a una pregunta incómoda: cuando programas con IA, ¿estás produciendo más valor, o solo estás pidiendo prestado tiempo que vas a devolver con intereses? Y como no me gusta dejar un diagnóstico sin tratamiento, cierro con la cura, que tiene una gracia particular: no es nueva. Es exactamente lo que la buena ingeniería lleva décadas predicando.

La ilusión de velocidad

Empecemos por el estudio que más ruido hizo, porque desarma la intuición de raíz. En 2025, el instituto de investigación METR montó un ensayo controlado aleatorizado (RCT, el estándar de oro de la evidencia) con 16 desarrolladores de código abierto experimentados, resolviendo 246 tareas reales sobre repositorios que ellos ya conocían al dedillo —proyectos de más de un millón de líneas y miles de estrellas—. A la mitad de las tareas se les permitía usar herramientas de IA de última generación; a la otra mitad, no. Se midió el tiempo real.

El resultado fue tan contraintuitivo que los propios autores lo destacaron: con IA, los desarrolladores tardaron un 19 % más en completar las tareas. No menos: más.

Pero el dato demoledor no es ese. Es el de la percepción:

Antes de empezar, esos mismos desarrolladores predijeron que la IA los aceleraría un 24 %. Y aquí viene lo bueno: después de haber ido más lentos, cuando se les preguntó, seguían creyendo que la IA los había acelerado un 20 %. Vivieron un frenazo del 19 % y lo recordaron como un empujón del 20 %. Entre lo que sentimos y lo que de verdad pasa hay casi cuarenta puntos de diferencia.

Y no es que esa gente sea torpe —son desarrolladores muy buenos, con años encima—. Es que todos, yo el primero, medimos el esfuerzo por cómo se siente, y teclear rápido se siente como avanzar. Es una trampa cognitiva de la que nadie se libra por experto que sea, y por eso duele reconocerla.

¿Por qué el desfase? Porque la parte visible —teclear código— se acelera muchísimo, y esa es la que sentimos. Pero el trabajo real de programar no es teclear: es leer, entender, verificar, integrar y corregir. Y ahí es donde la IA, cuando escupe código plausible pero no del todo correcto, mete un impuesto invisible. Ese impuesto tiene nombre, y lleva con nosotros desde 1992: deuda técnica.

Qué es la deuda técnica (y por qué la IA la acelera)

El término lo acuñó Ward Cunningham —sí, el mismo que inventó la wiki— en 1992, con una metáfora financiera que sigue siendo insuperable. Escribir código apurado, dijo, es como pedir un préstamo: te permite entregar hoy, pero contraes una deuda. Y como toda deuda, cobra intereses: cada cambio futuro sobre ese código apresurado cuesta un poco más. Puedes convivir con la deuda si pagas las cuotas (refactorizas); si la ignoras, los intereses se comen tu velocidad hasta que el proyecto se paraliza.

La metáfora encaja perfecto con lo que mide METR. La IA te da una velocidad de entrega altísima al principio. Pero si ese código entra sin revisar, sin probar, sin diseño, la deuda se acumula por debajo. Y como los intereses son compuestos, llega un punto en que la curva de deuda cruza a la de velocidad: a partir de ahí, mientras más rápido "produces", más lento avanzas.

La pregunta interesante no es si la IA genera deuda —todo código la genera—, sino si genera más, y de qué tipo. Y aquí es donde la investigación de 2026 se pone precisa.

El mapa de la deuda que introduce la IA

En 2026, cuatro investigadores —Ramtin Ehsani, Shriya Rawal, Yuanfang Cai y Preetha Chatterjee— publicaron en ACM TOSEM (la revista más prestigiosa de ingeniería de software) una revisión multivocal de la literatura titulada, con ironía deliciosa, Faster Code, Deeper Debt?. "Multivocal" significa que no solo revisaron papers académicos, sino también la voz de la trinchera: blogs, foros e informes de industria. En total, 104 fuentes.

Su hallazgo central es de dos capas. Primero, la IA amplifica la deuda técnica de toda la vida. Segundo —y esto es lo novedoso— inventa seis deudas que antes no existían.

Las tres deudas tradicionales que la IA agrava son las de siempre, solo que con esteroides: deuda de código (legibilidad y mantenibilidad, la más mencionada con diferencia), deuda de diseño (el modelo no conoce las decisiones arquitectónicas de tu proyecto, así que genera código que las viola) y deuda de documentación (nadie documenta lo que no escribió). Hasta ahí, nada que un buen equipo no reconozca.

Lo verdaderamente nuevo son las seis deudas propias de los LLM. Vale la pena conocerlas una por una, porque cada una tiene su propio antídoto:

De estas seis, la de procedencia —a quién pertenece el código que escupe un modelo— la estudia en detalle también el trabajo PromptDebt (2025), por si quieres tirar de ese hilo.

Para que no queden en abstracto, aterricémoslas en tu stack. Así se ven la deuda de prompts y la de diseño en un proyecto Laravel + Vue real:

// Lo que la IA genera por defecto: todo junto, sin dominio.
class InvoiceController
{
    public function store(Request $request)
    {
        $data = $request->validate([
            'client' => 'required|string',
            'amount' => 'required|numeric',
        ]);

        // regla de negocio incrustada en el controlador...
        $cents = (int) round($data['amount'] * 100);
        if ($cents < 0) abort(422, 'Monto inválido');

        // ...y Eloquent directo, sin repositorio ni caso de uso.
        $invoice = Invoice::create([
            'client' => $data['client'],
            'cents'  => $cents,
        ]);

        return response()->json($invoice, 201);
    }
}

// useInvoiceForm.ts — generado por IA. ¿Con qué prompt? Nadie lo versionó.
export function useInvoiceForm() {
  const amount = ref('')
  // la IA "decidió" esta regla; el prompt que la produjo se perdió
  const isValid = computed(() => Number(amount.value) > 0)
  // ¿y si mañana el negocio pide permitir 0? Hay que re-descubrir el prompt.
  return { amount, isValid }
}

Los números, sin adornos

Una taxonomía está muy bien, pero a un tech lead lo que lo convence son las cifras. Y la revisión de TOSEM reúne varias que, cuando las lees seguidas, quitan las ganas de seguir mergeando sin revisar:

Y esto no es una preocupación de blogueros: es agenda de la industria y de la academia. El panel Technical Debt in the AI Era de ICSE 2026 —la conferencia más importante del campo— lo puso sobre la mesa con dos datos que dan vértigo. Uno, de la consultora CAST: la deuda técnica mundial ya suma 61 mil millones de días-trabajo. Otro, de Gartner en su informe Predicts 2026:

La cura no es nueva (ya la conoces)

Aquí es donde el diagnóstico se vuelve, curiosamente, buenas noticias. Porque si lees la lista de remedios que la investigación propone contra la deuda de la IA, vas a sentir un déjà vu: es la buena ingeniería de siempre. La IA no cambió las reglas; subió las apuestas. Lo que antes era recomendable, ahora es indispensable.

No hay que inventar nada. Hay que aplicar, con más disciplina que nunca, cuatro cosas que probablemente ya sabes hacer:

Cierre

Volvamos a la pregunta del título. ¿Código más rápido, deuda más profunda? La evidencia de 2026 responde con un "depende", pero un depende con dirección clara: si sueltas el código de la IA directo a producción, sí —más rápido hoy, mucho más lento y más caro dentro de un año, con seis tipos nuevos de deuda que ni sabías que existían—. La ilusión de velocidad de METR es real, y es una trampa cognitiva: te sentirás productivo justo mientras acumulas el problema.

Pero la misma investigación que diagnostica el mal receta la cura, y resulta ser la ingeniería de siempre subida de intensidad: pruebas que respalden cada línea, un diseño limpio donde el código encaje, prompts versionados como el artefacto que son, y quality gates que vigilen lo que la revisión humana ya no alcanza. Nada de esto es nuevo. Lo nuevo es que dejó de ser opcional. La IA es una palanca extraordinaria —pero una palanca amplifica en ambos sentidos: multiplica tu buena ingeniería, y multiplica también la mala. Cuál de las dos, sigue dependiendo de ti.

Fuentes