Nivel inicial15 min de lectura · Publicado el

¿Qué es la deuda técnica? Definición y ejemplos

Deuda técnica: una tarjeta de crédito con el atajo como compra, el principal como el trabajo de limpiar el código y los intereses en cada cambio. Cada atajo cobra interesesrubentejera.com atajoprincipallimpiarlointeresescada cambioamortizar = refactorizar
El atajo es la compra con tarjeta; el principal, lo que costaría limpiar ese código; los intereses, el esfuerzo de más en cada cambio, que solo se paga al tocarlo. Refactorizar es amortizar.

La deuda técnica es el coste extra que pagas mañana por los atajos que tomas hoy en el código: cada cambio en esa parte cuesta más, hasta que alguien la limpia.

Tienes que entregar una funcionalidad el viernes. Copias y pegas un bloque, dejas un if más en una función que ya tenía demasiados y prometes arreglarlo «luego». Funciona. Pero la próxima vez que toques esa parte tardarás más, porque primero tendrás que entender el lío.

Es como pagar con la tarjeta de crédito: compras hoy lo que no podrías pagar al contado y, mientras no devuelvas el dinero, pagas intereses.

Qué es la deuda técnica

La deuda técnica es una metáfora para hablar de la calidad interna del código con quien no programa. Martin Fowler la explica así: los defectos de calidad interna hacen que modificar y ampliar el sistema cueste más de lo que debería; ese esfuerzo de más en cada funcionalidad nueva son los intereses, y limpiar la estructura es pagar el principal (resumen nuestro de su artículo).

Parte En la tarjeta de crédito En el código
Principal Lo que te prestaron El trabajo de limpiar el código mal resuelto: duplicado, enrevesado, sin tests
Intereses Lo que pagas cada mes El tiempo de más que cuesta cada cambio en ese código
Amortizar Devolver el préstamo Limpiar el código, sobre todo refactorizando: mejorar su estructura sin cambiar lo que hace

Ejemplos de deuda técnica

La deuda técnica no es una cosa abstracta: se ve en el código. Estos son ejemplos concretos, de los más pequeños a los más grandes.

Un ejemplo completo: la misma regla copiada en dos sitios

Una tienda calcula el total del carrito y, meses después, alguien copia ese cálculo para la factura. Es el atajo: funciona y ahorra media hora. Hoy llega un requisito nuevo, un 10 % de descuento a partir de 100 €, y se añade donde se estaba mirando, en el carrito:

// tienda.mjs: el mismo cálculo, copiado en dos sitios.

// Lo que ve el cliente en el carrito.
export function totalCarrito(lineas) {
  let subtotal = 0;
  for (const linea of lineas) subtotal += linea.precio * linea.unidades;
  // Nuevo requisito: 10 % de descuento a partir de 100 €.
  if (subtotal >= 100) subtotal = subtotal * 0.9;
  return Math.round(subtotal * 1.21 * 100) / 100;
}

// Lo que se le cobra en la factura (copiado del carrito hace meses).
export function totalFactura(lineas) {
  const subtotal = lineas.reduce((suma, l) => suma + linea.precio * linea.unidades, 0);
  return Math.round(subtotal * 1.21 * 100) / 100;
}

const pedido = [
  { precio: 60, unidades: 1 },
  { precio: 20, unidades: 2 },
];
console.log("Carrito:", totalCarrito(pedido), "€");
console.log("Factura:", totalFactura(pedido), "€");
node tienda.mjs
Carrito: 108.9 €
Factura: 121 €

El cliente ve un precio y se le cobra otro: el cambio debía tocar dos sitios, nadie lo sabía y no había un test que lo avisara. Ese es el coste del atajo; el interés, acordarse de los dos sitios en cada cambio. Más abajo, en «Cómo pagarla sin parar el proyecto», está la versión arreglada.

Otros ejemplos habituales

  • Números sueltos sin nombre. El 1.21 del ejemplo es el IVA, pero el código no lo dice; cambiarlo obliga a buscar cada aparición. Son los números mágicos.
  • Funciones con demasiados caminos. Una función que se ha ido llenando de if hasta que nadie se atreve a tocarla. Su complejidad ciclomática lo delata.
  • Clases que lo hacen todo. Una clase que calcula, guarda, envía correos y genera informes, como el God Object: cualquier cambio la toca.
  • Código sin tests. No se ve en la pantalla, pero cada cambio cuesta más, porque hay que comprobarlo a mano o arriesgarse. Los tests con TDD son la forma de no acumularla.
  • Configuración escrita dentro del código. Para desplegar en otro entorno hay que cambiar el código. The Twelve-Factor App explica cómo sacarla.
  • Comentarios que ya no dicen la verdad y bloques de código comentado «por si acaso». Confunden a quien lee; lo cuenta el artículo de comentarios en código limpio.
  • Dependencias sin actualizar. Una versión del framework que ya no recibe parches de seguridad. Cuanto más se espera, más saltos de versión hay que dar de golpe.
  • CSS que crece sin orden, donde cada arreglo añade un !important. La charla de Carmen Ansio sobre refactorizar CSS heredado trata justo esto.

Los cuatro tipos de deuda técnica

Martin Fowler ordena la deuda en dos ejes: si se tomó a sabiendas (deliberate) o sin darse cuenta (inadvertent), y si fue una decisión prudente (prudent) o imprudente (reckless). Cada cuadrante de su esquema lleva una frase típica (traducción nuestra):

Imprudente Prudente
A sabiendas «No tenemos tiempo para diseñar» «Tenemos que lanzar ya y asumir las consecuencias»
Sin darse cuenta «¿Qué es eso de las capas?» «Ahora sabemos cómo deberíamos haberlo hecho»

Leídos con un ejemplo (explicación nuestra):

  • Imprudente y a sabiendas: el equipo sabe que hay una forma mejor y la salta sin medir lo que costará.
  • Prudente y a sabiendas: se acepta el coste porque llegar a una fecha compensa, y se planea pagarlo.
  • Imprudente y sin darse cuenta: el equipo no conoce las buenas prácticas y acumula deuda sin verla.
  • Prudente y sin darse cuenta: al terminar, el equipo descubre cómo debería haberlo hecho.

Del último cuadrante, Fowler dice que es inevitable incluso para los equipos que diseñan muy bien, y que por eso hay que contar con él. Y añade que la distinción útil no es entre tener deuda o no tenerla, sino entre deuda prudente e imprudente (traducción nuestra).

De dónde viene el término

La metáfora es de Ward Cunningham, en un informe de experiencia para la conferencia OOPSLA de 1992, «The WyCash Portfolio Management System». El párrafo original dice:

«Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite. […] The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt.»

En español (traducción nuestra): «Entregar código hecho a la primera es como endeudarse. Un poco de deuda acelera el desarrollo, siempre que se devuelva pronto con una reescritura. […] El peligro llega cuando la deuda no se devuelve. Cada minuto dedicado a código que no está del todo bien cuenta como intereses de esa deuda».

Fíjate en el contexto (lectura nuestra del informe): Cunningham no habla de escribir código malo a propósito. Habla de código inmaduro, que funciona y el cliente acepta, y del riesgo de no consolidarlo después con una reescritura.

Señales de que tienes deuda técnica

Los ejemplos de arriba están en el código. Estas señales se notan en el día a día del equipo:

  • Un cambio pequeño obliga a tocar muchos ficheros.
  • Nadie quiere tocar cierto módulo «porque se rompe».
  • Hay que acordarse de cambiar lo mismo en varios sitios a la vez.
  • Los tests fallan a menudo y se ignoran, o no hay tests.
  • Las estimaciones de esa parte del sistema siempre se quedan cortas.
  • Los errores reaparecen en la misma zona después de «arreglarlos».

Cómo medir la deuda técnica

No hay un único número que diga «tienes tanta deuda». Lo que sí puedes medir son sus dos partes por separado (planteamiento nuestro, a partir de la distinción de Fowler entre intereses y principal).

Los intereses: dónde cambias más a menudo

Si la deuda solo cobra al tocar el código, lo primero es saber qué se toca. El historial de Git lo dice. Este comando cuenta cuántos commits han modificado cada fichero en el último año:

git log --format=format: --name-only --since="12 months ago" | grep -v '^$' | sort | uniq -c | sort -rn | head -10

En un repositorio de prueba con cuatro ficheros, el resultado es:

     10 src/pedidos.js
      5 src/usuarios.js
      2 src/informes.js
      1 src/utilidades.js

Ejecutado con Git 2.53.0. Los ficheros de arriba son los que más intereses pueden cobrar.

El principal: cuánto cuesta limpiarlo

Aquí ayudan las métricas de código: la complejidad ciclomática de cada función (ese artículo explica cómo medirla con ESLint, radon o lizard), el código duplicado y el tamaño de las clases.

Juntar las dos

Un fichero complejo que nadie toca puede esperar. Uno sencillo que cambia a diario, también. El que hay que mirar es el que sale arriba en las dos listas: complejo y cambiado a menudo. Es un criterio nuestro, pero se deriva directamente de lo que dice Fowler sobre los intereses.

Las herramientas que le ponen cifra

Herramientas como SonarQube traducen los problemas de mantenibilidad que detectan en tiempo. Según su documentación (SonarQube Server 2026.5):

  • La deuda técnica es la suma de los costes estimados de corregir cada problema de mantenibilidad.
  • El ratio de deuda técnica divide esa deuda entre lo que costaría desarrollar el código, calculado por defecto como 30 minutos por línea.
  • Ese ratio da una nota de mantenibilidad de la A (5 % o menos) a la E (50 % o más).

Es una estimación hecha con reglas, no el tiempo real que perderá tu equipo. Sirve para ver tendencias (¿sube o baja de un mes a otro?) mejor que como cifra absoluta.

Cómo pagarla sin parar el proyecto

  1. Hazla visible. Apunta la deuda donde el equipo la vea (en el tablero, en tickets) y explica su coste en tiempo, no en términos técnicos.
  2. Paga primero lo que más se toca. Fowler lo dice así: dedicar más tiempo a limpiar las zonas que se modifican a menudo, y dejar en paz las que están feas pero estables (traducción nuestra).
  3. Escribe tests antes de limpiar. Son la red que te permite refactorizar sin miedo a romper nada.
  4. Paga a plazos. Deja el código un poco mejor cada vez que pases por él: es la regla del boy scout.
  5. Si pides deuda a sabiendas, apúntalo. Una deuda prudente con fecha de pago es una decisión; sin fecha, se convierte en olvido.

El ejemplo de la tienda, pagado

En el caso del carrito y la factura hay dos pasos. Primero se corrige el fallo: la factura tiene que aplicar el descuento, y eso sí cambia lo que hace el programa. Después se refactoriza: la regla queda en un solo sitio, con nombre para cada número, y unos tests la fijan:

// precio.mjs: la regla vive en un solo sitio.
const IVA = 0.21;
const UMBRAL_DESCUENTO = 100;
const DESCUENTO = 0.1;

export function totalAPagar(lineas) {
  let subtotal = lineas.reduce((suma, linea) => suma + linea.precio * linea.unidades, 0);
  if (subtotal >= UMBRAL_DESCUENTO) subtotal *= 1 - DESCUENTO;
  return Math.round(subtotal * (1 + IVA) * 100) / 100;
}

// El carrito y la factura ya no calculan: preguntan.
export const totalCarrito = (lineas) => totalAPagar(lineas);
export const totalFactura = (lineas) => totalAPagar(lineas);
// precio.test.mjs
import { test } from "node:test";
import assert from "node:assert/strict";
import { totalAPagar, totalCarrito, totalFactura } from "./precio.mjs";

test("sin descuento por debajo de 100 €", () => {
  assert.equal(totalAPagar([{ precio: 50, unidades: 1 }]), 60.5);
});

test("con 100 € justos ya hay descuento", () => {
  assert.equal(totalAPagar([{ precio: 100, unidades: 1 }]), 108.9);
});

test("10 % de descuento por encima de 100 €", () => {
  const pedido = [
    { precio: 60, unidades: 1 },
    { precio: 45, unidades: 2 },
  ];
  assert.equal(totalAPagar(pedido), 163.35);
});

test("el carrito y la factura cobran lo mismo", () => {
  const pedido = [
    { precio: 60, unidades: 1 },
    { precio: 20, unidades: 2 },
  ];
  assert.equal(totalCarrito(pedido), totalFactura(pedido));
});
node --test
✔ sin descuento por debajo de 100 € (0.733608ms)
✔ con 100 € justos ya hay descuento (0.128172ms)
✔ 10 % de descuento por encima de 100 € (0.108445ms)
✔ el carrito y la factura cobran lo mismo (0.1216ms)
ℹ tests 4
ℹ suites 0
ℹ pass 4
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 62.823996

Ejecutado con Node 24.21.0. El test de 100 € justos fija el límite del >=, y el último avisa si el carrito y la factura vuelven a separarse. El próximo cambio de la regla se hace una sola vez. En un proyecto real, el orden seguro es el contrario al de este resumen: primero un test que demuestre el fallo (la factura sin descuento), después la corrección y, con los tests en verde, el refactor; la regla del boy scout lo explica paso a paso.

Deuda técnica e inteligencia artificial

Lo que sigue es interpretación nuestra, no de Fowler ni de Cunningham, salvo la cita de DORA.

Un asistente de IA escribe código muy rápido, y tiende a seguir los patrones que encuentra en el proyecto. En un código limpio y con tests, eso acelera el trabajo bueno. En uno lleno de atajos, como el carrito y la factura de arriba, puede copiar el atajo una tercera vez sin que nadie lo note, porque nada falla al momento. La deuda de siempre, pedida más deprisa.

El informe DORA de 2025 llega a una conclusión parecida a escala de organización: «AI’s primary role is as an amplifier, magnifying an organization’s existing strengths and weaknesses» (el papel principal de la IA es el de amplificador: magnifica las fortalezas y debilidades que la organización ya tiene; traducción nuestra).

Por eso el enfoque de la IA Limpia apoya el trabajo con agentes en lo mismo que mantiene baja la deuda sin IA: tests que avisan, refactoring en pasos pequeños y revisión humana de lo que se fusiona; cómo hacer esa revisión está en la checklist para revisar código generado por IA.

Hay además una deuda que no está en el código: cuando el equipo acepta lo que genera el agente sin entenderlo, que llevado al extremo es el vibe coding, el código puede estar bien y aun así nadie sabe cómo funciona. Se llama deuda cognitiva, y se paga de otra forma.

La IA acelera lo que ya existe: buenas prácticas o deuda técnica.

Para seguir leyendo

Fuentes

  • Ward Cunningham, The WyCash Portfolio Management System, informe de experiencia de OOPSLA ’92 (1992): origen de la metáfora y cita literal. Leído el 9 de noviembre de 2026.
  • Martin Fowler, Technical Debt: intereses y principal, por qué los intereses solo se pagan al tocar el código y qué zonas limpiar primero. Publicado en 2003 y reescrito en 2019; leído el 9 de noviembre de 2026.
  • Martin Fowler, Technical Debt Quadrant (2009): los cuatro tipos. Las frases de la tabla son las de su esquema, traducidas por nosotros; las explicaciones de cada cuadrante son nuestras. Leído el 9 de noviembre de 2026.
  • SonarSource, Understanding measures and metrics (SonarQube Server 2026.5): definición de deuda técnica, ratio y nota de mantenibilidad. Consultado el 9 de noviembre de 2026.
  • El código se ha ejecutado con Node 24.21.0 y Git 2.53.0; el comando de Git, sobre un repositorio de prueba creado para este artículo.
  • DORA, State of AI-assisted Software Development 2025: la IA como amplificador. Frase leída en la página de presentación del informe el 9 de noviembre de 2026.
  • La relación con la IA es interpretación nuestra, no de Fowler ni de Cunningham.
  • Enlaces de «Para seguir leyendo» comprobados el 7 de noviembre de 2026: Wikipedia, Genbeta (redirige desde genbetadev.com) y Javier Garzás.