Nivel inicial17 min de lectura · Revisado el

Cómo revisar código generado por IA: checklist en 6 pasos

Revisar código generado por IA como un ticket: precio.js bien; usuarios.js no se pidió, el paquete nuevo no existe y un test falla con 100 €. Revisar código de la IArubentejera.com TU CAMBIOprecio.jsprecio.test.jsusuarios.jspaquete nuevotests 3 ✔ 1 ✖lo que pedisteno lo pedisteno existe en npmfalla con 100 €
Como el ticket de la compra antes de pagar: cada línea del cambio tiene que ser algo que pediste y que existe. Aquí sobra un fichero, el paquete nuevo no existe en npm y el test de los 100 € justos falla.

Para revisar código generado por IA, empieza por los tests y comprueba que el cambio hace solo lo que pediste, que todo lo que usa existe y que no abre agujeros de seguridad. Este artículo lo explica paso a paso.

Le pides a un agente de IA un cambio pequeño y en un minuto tienes veinte líneas que compilan, con su test en verde. Da ganas de aceptarlo y seguir; hacerlo siempre tiene nombre, vibe coding. El problema es que un código que parece correcto y un código correcto no son lo mismo, y la diferencia solo la ve quien lo revisa.

Piensa en el ticket de la compra. Antes de pagar, lo repasas: que cada línea sea algo que has metido en el carro, que no haya un producto que no has cogido y que el total cuadre. No hace falta ser contable; hace falta mirar. Revisar código generado por IA es lo mismo: comprobar línea a línea que el cambio es lo que pediste, que todo lo que usa existe y que los tests (el total) cuadran.

Aquí tienes una lista de comprobación en seis pasos, con un ejemplo real ejecutado, apoyada en la guía de revisión de código de Google y en los estudios que hemos podido leer en su original.

Qué cambia al revisar código generado por IA

En una revisión de código (code review) normal, otra persona escribió el cambio y puedes preguntarle por qué. Con un agente también puedes preguntar, y te responderá, pero su explicación es otro texto generado: no tiene por qué reflejar cómo llegó al código. Tú eres quien firma el cambio.

La guía de Google lo deja claro para cualquier revisión: hay que mirar cada línea que te han pedido revisar. Admite que algunas cosas, como ficheros de datos o «código generado», se pueden mirar por encima, pero no un bloque escrito por una persona (traducción nuestra). Interpretación nuestra: esa excepción piensa en código que produce una herramienta de forma determinista, siempre igual, a partir de una definición. El código que escribe un agente de IA no es de ese tipo. Cambia en cada respuesta y puede equivocarse como una persona, así que merece la revisión de una persona.

La misma guía da el criterio para aprobar: un cambio se acepta cuando mejora la salud del código en conjunto, aunque no sea perfecto, y no se acepta si la empeora. Si aceptas cambios que la empeoran un poco cada vez, lo que acumulas tiene nombre: deuda técnica. Y un agente produce cambios mucho más rápido que una persona, así que también puede acumularla más rápido. Aceptar un cambio que no entiendes acumula otra deuda, que no está en el código sino en el equipo: la deuda cognitiva.

Checklist para revisar código generado por IA

  1. Tests primero: ¿hay un test para el caso que te importa? ¿Fallaría si el código estuviera mal? ¿Ha tocado o borrado tests que ya existían?
  2. Alcance: ¿toca solo los ficheros y el comportamiento que pediste?
  3. Dependencias: ¿existe cada paquete nuevo? ¿Hacía falta, o el proyecto ya tenía algo igual?
  4. Seguridad: datos de entrada, secretos, permisos y accesos.
  5. Duplicación y complejidad: ¿reinventa algo que ya existe? ¿Es más complicado de lo necesario?
  6. Nombres: ¿se entiende qué hace cada cosa sin leer su interior?

Para verlo en acción, usaremos un ejemplo. Un proyecto de una tienda en Node.js tiene ya una función redondearCentimos en src/dinero.js y un test que comprueba que a un usuario se le muestra su alias. El encargo al agente es: «Aplica un 10 % de descuento a los pedidos de 100 € o más».

La respuesta que vamos a revisar la hemos escrito nosotros para el artículo. No es la salida de un modelo concreto: reúne en pocas líneas un problema de cada punto de la lista, para poder enseñarlos. Los comandos y sus salidas, en cambio, son reales. Este es el código propuesto (el nombre del paquete lo dejamos como marcador; verás por qué en el paso 3):

// src/precio.js
import { redondear } from '<nombre-que-propone-el-agente>';

export function calcular(t) {
  if (t > 100) {
    return redondear(t * 0.9);
  }
  return t;
}

Y este, el test que lo acompaña:

// test/precio.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { calcular } from '../src/precio.js';

test('aplica el descuento', () => {
  assert.ok(calcular(200) < 200);
});

1. Tests primero

Lo primero no es leer el código, sino preguntarse: ¿qué tendría que pasar? El encargo dice «100 € o más». El caso que más preocupa es justo el borde: un pedido de 100 € exactos. Si el código que toca el agente no tiene tests, caracterízalo antes de que lo toque; y si el test lo escribes antes que el código, es TDD con IA.

Mira el test que trae el cambio: comprueba que 200 € bajan de precio, nada más. No dice cuánto, ni qué pasa con 100 €. Para poder ejecutarlo, cambiamos de momento el import por la función redondearCentimos del proyecto:

import { redondearCentimos as redondear } from './dinero.js';

Y lanzamos los tests:

npm test
✔ redondea a céntimos
✔ aplica el descuento
ℹ tests 2
ℹ pass 2
ℹ fail 0

Todo en verde. Pero un test en verde no demuestra nada si no habría fallado con el código mal. La guía de Google lo pide expresamente: preguntarse si los tests fallarían de verdad con el código roto, porque los tests no se prueban a sí mismos y «una persona tiene que asegurarse de que son válidos» (traducción nuestra).

Así que escribes tú los tests que describen el encargo, con números concretos, y sustituyen al de «aplica el descuento»:

// test/precio.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { calcular } from '../src/precio.js';

test('un pedido de 100 € justos lleva el 10 % de descuento', () => {
  assert.equal(calcular(100), 90);
});

test('un pedido de 99,99 € no lleva descuento', () => {
  assert.equal(calcular(99.99), 99.99);
});

test('un pedido de 150 € se queda en 135 €', () => {
  assert.equal(calcular(150), 135);
});
npm test
✔ redondea a céntimos
✖ un pedido de 100 € justos lleva el 10 % de descuento
✔ un pedido de 99,99 € no lleva descuento
✔ un pedido de 150 € se queda en 135 €
ℹ tests 4
ℹ pass 3
ℹ fail 1

  100 !== 90

Ahí está el fallo: el código usa t > 100 («más de 100») cuando el encargo decía «100 o más» (>=). Es un error de una sola tecla, el tipo de error que se te escapa leyendo y que un test con el número justo encuentra al momento.

Fíjate también, en el cambio tal como lo entregó el agente, en los tests que ya existían. Interpretación nuestra: un cambio que se pone en verde borrando, saltando o rebajando tests no está en verde de verdad. El cambio del agente está en su propio commit, así que main...HEAD compara solo lo que entregó, sin lo que tú has tocado para revisarlo:

git diff --stat main...HEAD -- test/
 test/precio.test.js   | 7 +++++++
 test/usuarios.test.js | 7 -------
 2 files changed, 7 insertions(+), 7 deletions(-)

El cambio ha borrado test/usuarios.test.js, el que comprobaba el alias. Ahora verás por qué.

Por eso los tests van primero: son el contrato del cambio. Si los escribes antes de pedirle el código al agente, mejor todavía: es la idea de TDD, el desarrollo dirigido por tests. Y si dudas de qué tipo de test escribir, tienes los tipos de pruebas de software.

Y que esos tests los pase también una CI que el agente no controla, no solo su máquina: hook pre-commit y CI para agentes.

2. El alcance del cambio

Pediste un descuento. ¿Qué ficheros ha tocado? Antes de leer nada, mira el resumen del cambio con Git:

git diff --stat main...HEAD
 package.json          | 3 ++-
 src/precio.js         | 8 ++++++++
 src/usuarios.js       | 2 +-
 test/precio.test.js   | 7 +++++++
 test/usuarios.test.js | 7 -------
 5 files changed, 18 insertions(+), 9 deletions(-)

src/usuarios.js no tiene nada que ver con precios. Es la línea del ticket que no has metido en el carro. Veamos qué ha cambiado:

git diff main...HEAD -- src/usuarios.js
 export function nombreVisible(usuario) {
-  return usuario.alias ?? usuario.nombre;
+  return usuario.nombre;
 }

Ha quitado el alias de los usuarios y, con él, el test que lo protegía. Puede que pareciera una «limpieza», pero cambia lo que ve la gente en la web, y nadie lo ha pedido. Ese cambio se deshace, el test vuelve y, si hiciera falta, se propone aparte.

Dos consejos de la guía de Google para el autor de un cambio, que sirven igual cuando el autor es un agente:

  • Un cambio, una cosa. Un cambio pequeño se revisa antes, con más cuidado, y es más fácil de deshacer. La guía da una orientación, no una regla: unas 100 líneas suele ser un tamaño razonable y 1.000 suele ser demasiado.
  • El revisor puede rechazar un cambio solo por ser demasiado grande. Si el agente te devuelve 600 líneas, pídele que lo divida.

3. Dependencias inventadas

El código importa un paquete y lo añade a package.json. ¿Existe? Se comprueba con un comando:

npm view <nombre-que-propone-el-agente>

En el ejemplo, npm responde con un error E404: ese paquete no existe en el registro. Y la propia ejecución lo delata: con el import original, npm test falla con ERR_MODULE_NOT_FOUND, porque no hay nada que importar. Es una alucinación del modelo: propone el nombre que le parece más probable, no uno que haya comprobado.

No es un caso raro de nuestro ejemplo. Un estudio de Spracklen y otros, aceptado en el congreso USENIX Security 2025, generó 576.000 fragmentos de código en Python y JavaScript con 16 modelos de lenguaje disponibles a principios de 2024. De media, al menos el 5,2 % de los paquetes que recomendaban los tres modelos de OpenAI probados (GPT-3.5, GPT-4 y GPT-4 Turbo) no existían, y el 21,7 % en los trece de código abierto. JavaScript salió peor que Python: 21,3 % de paquetes inventados frente a 15,8 %. En total encontraron más de 205.000 nombres inventados distintos.

Lo peligroso no es solo que la instalación falle. El estudio explica el ataque: alguien registra en npm o PyPI un paquete con el nombre que la IA suele inventar, con código malicioso dentro, y espera a que otra persona lo instale siguiendo la sugerencia. A esto se le ha empezado a llamar slopsquatting. Y los modelos repiten sus invenciones: en una de sus pruebas, el 43 % de los paquetes inventados volvió a aparecer en las diez repeticiones de la misma petición. Por eso en este artículo no damos el nombre del paquete del ejemplo: publicar un nombre inexistente es dejarlo a mano de quien quiera registrarlo.

Ten en cuenta el alcance del estudio: son porcentajes de paquetes recomendados, no de programas, y los propios autores reconocen que no pudieron estudiar los modelos más nuevos, que pueden comportarse de otra forma. Pero la comprobación cuesta un comando. Para cada dependencia nueva:

  • Comprueba que existe y que es la que crees: quién la publica, si tiene repositorio y si se usa.
  • Pregúntate si hace falta. En el ejemplo, el proyecto ya tenía redondearCentimos. La dependencia sobraba aunque hubiera existido.
  • Sospecha también de un paquete que exista pero sea muy reciente y tenga el nombre que el agente te propuso: es justo el ataque que describe el estudio.

4. Seguridad del código generado por IA

La seguridad no se ve en un test que pasa. Repasa, como mínimo: Si el agente lee datos de fuera (webs, issues, correos), revisa también el riesgo de prompt injection.

  • Datos de entrada: todo lo que llega del usuario o de fuera (formularios, URL, ficheros) se valida antes de usarlo. Y si se mete en una consulta a la base de datos, va como parámetro, nunca pegado al texto de la consulta.
  • Secretos: ninguna contraseña, clave ni token escrito en el código o en un fichero que se suba al repositorio.
  • Permisos: que una ruta o una función nueva compruebe quién la llama, igual que las de al lado.
  • Lo que se registra: que los logs no guarden datos personales ni secretos.

Hay un motivo para no fiarse de la sensación de seguridad. En el estudio de Perry y otros (CCS 2023), 47 personas resolvieron tareas de programación relacionadas con la seguridad; parte de ellas, con un asistente de IA basado en codex-davinci-002 de OpenAI. Quienes usaron el asistente escribieron soluciones inseguras más a menudo en cuatro de las cinco tareas y, además, creían más a menudo que su código era seguro. Es un estudio pequeño y con un modelo antiguo, así que no permite decir cuánto falla la IA de hoy. Sí deja un aviso que no caduca: el código fluido da una confianza que no siempre merece.

Si el cambio toca algo delicado (pagos, permisos, datos personales) y no te sientes capaz de revisarlo, la guía de Google es clara: busca a alguien que sí lo sea.

5. Duplicación y complejidad

El paquete inventado servía para redondear, y el proyecto ya tenía redondearCentimos. Es una duplicación clásica: dos formas de hacer lo mismo, que con el tiempo dejarán de comportarse igual. Un agente solo ve del proyecto lo que ha leído en esa sesión, así que es fácil que reinvente lo que ya existe. Interpretación nuestra: por eso esta comprobación pesa más con código generado.

Busca también lo contrario: código más complicado de lo necesario. La guía de Google pide vigilar en especial el exceso de ingeniería, es decir, código más genérico de lo que hace falta o funciones que nadie ha pedido todavía, y animar a quien escribe el código a que resuelva el problema que sabe que hay que resolver ahora, no el que podría llegar. Son los principios DRY y YAGNI, que tienes explicados en YAGNI, KISS y DRY.

6. Nombres

calcular(t) no dice qué calcula ni qué es t. Y 100 y 0.9 son números mágicos: quien lea el código tendrá que adivinar de dónde salen. La guía de Google lo resume en una frase: un buen nombre es lo bastante largo para comunicar del todo qué es o qué hace (traducción nuestra). Más ideas en nombres con sentido.

El cambio, revisado

Con todo lo anterior, el cambio queda así: sin la dependencia inventada, sin tocar usuarios.js ni su test, con el borde corregido y con nombres que se entienden.

// src/precio.js
import { redondearCentimos } from './dinero.js';

const MINIMO_PARA_DESCUENTO = 100; // euros
const DESCUENTO = 0.10;

export function totalConDescuento(total) {
  if (total < MINIMO_PARA_DESCUENTO) return total;
  return redondearCentimos(total * (1 - DESCUENTO));
}

Los tests son los tres del paso 1, con el nuevo nombre de la función:

// test/precio.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { totalConDescuento } from '../src/precio.js';

test('un pedido de 100 € justos lleva el 10 % de descuento', () => {
  assert.equal(totalConDescuento(100), 90);
});

test('un pedido de 99,99 € no lleva descuento', () => {
  assert.equal(totalConDescuento(99.99), 99.99);
});

test('un pedido de 150 € se queda en 135 €', () => {
  assert.equal(totalConDescuento(150), 135);
});
npm test
✔ redondea a céntimos
✔ un pedido de 100 € justos lleva el 10 % de descuento
✔ un pedido de 99,99 € no lleva descuento
✔ un pedido de 150 € se queda en 135 €
✔ muestra el alias si lo hay
ℹ tests 5
ℹ pass 5
ℹ fail 0
git diff --stat main
 src/precio.js       |  9 +++++++++
 test/precio.test.js | 15 +++++++++++++++
 2 files changed, 24 insertions(+)

Dos ficheros, los que tocaba, y el test del alias de vuelta. El ticket cuadra.

En la práctica, no hace falta que corrijas tú todo: puedes devolverle al agente la lista de problemas y tus tests, y volver a revisar lo que te traiga. Lo importante es que el criterio para aceptarlo lo pones tú.

Revisión de código con IA: herramientas que ayudan

También hay herramientas que usan IA para revisar código. Son útiles como segunda opinión, sobre todo para lo que se escapa por cansancio. Dos ejemplos, según su documentación oficial a 9 de noviembre de 2026:

  • Copilot code review, de GitHub, revisa pull requests y propone arreglos. Su documentación avisa de que no garantiza encontrar todos los problemas, de que se equivocará y de que hay que completar su revisión con la de una persona. Por defecto, sus revisiones no cuentan como aprobación obligatoria.
  • Claude Code (versión 2.1.319) incluye /code-review, que busca errores en los cambios, y /security-review, que busca vulnerabilidades en los cambios de tu rama. Su guía de buenas prácticas explica que /code-review revisa en un subagente con un contexto nuevo, que no ha visto la conversación en la que se escribió el código, y avisa de que un revisor al que se le pide encontrar problemas siempre encontrará algo: si arreglas todo lo que señala, acabas con capas de abstracción y tests de más. Su documentación de seguridad añade que revisar el código y los comandos propuestos es responsabilidad de quien los aprueba. Cómo encaja la revisión en un flujo completo, del plan al commit, está en el tutorial de cómo usar Claude Code.

Interpretación nuestra: una revisión con IA en un contexto nuevo es mejor que pedirle a la misma sesión que revise lo que acaba de escribir, pero no cierra el círculo. Puede tener los mismos puntos ciegos y no sabe qué pediste de verdad. Lo que sí sabe qué pediste es tu test. Cómo montar un revisor propio que solo puede leer, con un ejemplo ejecutado, está en Claude Code subagentes.

Errores frecuentes al revisar código de IA

  • Aprobar porque los tests pasan, sin mirar si los tests comprueban algo ni si alguno ha desaparecido. Lo has visto en el paso 1.
  • Revisar solo lo que te enseña la herramienta. El resumen de ficheros cambiados (git diff --stat) es lo primero, no lo último.
  • Aceptar un cambio enorme «porque ya está hecho». Si no puedes entenderlo entero, pide que se divida.
  • Fiarse del tono. Una explicación segura y bien escrita no es una prueba de que el código funcione.
  • Pedirle a la misma sesión que revise su propio cambio y dar el resultado por bueno. Sirve para encontrar cosas, no para decidir.

Tu siguiente paso

  1. En el próximo cambio que te proponga un agente, ejecuta git diff --stat antes de leer una sola línea, y mira aparte la carpeta de tests.
  2. Escribe un test con el caso del borde (el número justo, la lista vacía, el usuario sin permisos) y comprueba que pasa.
  3. Si quieres que la revisión sea continua y no al final, prueba a trabajar con el agente como en pair programming: tú escribes el test, él el código, y tú navegas.

La idea de fondo de este blog es que la IA acelera lo que ya haces: si revisas bien, acelera el buen código; si no, acelera la deuda. Está explicada en la IA Limpia.

Fuentes

Consultadas el 9 de noviembre de 2026.