Revisión de código con IA: lo que atrapa y lo que se le pasa
Guía/ 12 min de lectura
Lo que la revisión de código con IA atrapa (casos sin manejar, nombres, pruebas que faltan) y lo que se le pasa (reglas de negocio, decisiones, seguridad), y cómo repartirla.
- IA
- QA
En este artículo (8)
La revisión de código con IA atrapa bien lo mecánico: errores que se demuestran con una entrada, casos sin manejar, nombres confusos y pruebas que faltan. Se le pasa lo que no está en el código: reglas de negocio, decisiones de producto y el contexto de seguridad. Úsala como primer filtro y deja la aprobación a una persona.
Esto no es una comparación de herramientas ni un estudio con cifras: es cómo repartimos el trabajo en la práctica, con un cambio de ejemplo que corrimos, el archivo de instrucciones que le damos al revisor y la regla que obliga a que una persona apruebe las rutas sensibles. Si quieres montar el revisor como subagente, eso está en el artículo del subagente revisor; aquí va qué esperar de él y qué no.
Lo que la revisión de código con IA atrapa: lo mecánico
Llamamos mecánico a todo lo que se puede comprobar leyendo el diff y el código que lo rodea, sin saber nada del negocio. La guía de revisión de Google (qué buscar en una revisión de código) pide revisar funcionalidad, complejidad, pruebas, nombres y comentarios, y leer cada línea que te asignaron. Esa última parte es la que un revisor de IA hace sin cansarse: no se salta el archivo 14 de un cambio de 20.
Este es un cambio real de tamaño y forma, con números ilustrativos. Calcula el costo de envío de un carrito:
// lib/shipping.js: el cambio que se revisa
export function shippingCost(cart) {
const subtotal = cart.items.reduce((sum, item) => sum + item.price * item.qty, 0);
return subtotal >= 999 ? 0 : 149;
}
shippingCostrecibe el carrito completo.subtotalsuma precio por cantidad de cada producto, empezando en 0.- Si el subtotal llega a 999, el envío es gratis; si no, cuesta 149.
Lo corrimos con Node 22. Con un carrito sin items lanza TypeError: Cannot read properties of undefined (reading 'reduce'); con una cantidad negativa devuelve 149 sin quejarse; con exactamente 999 devuelve 0. Eso es lo que un revisor de IA suele señalar en un cambio así, y lo puede demostrar con una entrada:
- Casos sin manejar:
cart.itemsindefinido, cantidades negativas o con decimales. - Números mágicos: 999 y 149 sin nombre; una constante con nombre dice qué son y deja un solo lugar para cambiarlos.
- Pruebas que faltan: no hay prueba para el límite exacto (999) ni para el carrito vacío.
- Nombres:
subtotalestá bien aquí, pero un revisor marca cuando un nombre promete algo distinto de lo que el código calcula.
También es bueno con lo que se repite en todo el repo: un await que falta, un error que se traga un catch vacío, una variable de entorno leída sin valor por defecto, un secreto pegado en un fixture. Son errores que no dependen de quién eres ni de qué vendes.
Desliza la figura para verla completa
Lo que no está en el código: reglas de negocio, decisiones y contexto de seguridad
Ahora la regla: en esta tienda de ejemplo, el envío es gratis desde 999 después de descuentos. Corrimos la función con 1,100 en productos y un cupón de 200: el cliente paga 900 y la función devuelve 0. Envío gratis que no tocaba. El código es coherente consigo mismo; el error es contra una regla que vive en un ticket, en una conversación o en la cabeza de quien lleva la tienda. Quien solo lee el diff no tiene cómo saberlo, sea persona o modelo.
Pasa lo mismo con tres tipos de cosas:
- Reglas de negocio. Qué se cobra, cuándo se reembolsa, qué pasa con un pedido ya pagado. El código puede estar bien escrito y hacer lo contrario de lo acordado.
- Decisiones. Si la función debería existir, por qué se eligió esa librería, qué se aceptó no resolver. La guía de Google lo dice claro: quien revisa puede negar un cambio bien diseñado si agrega algo que no quieres en tu sistema (el estándar de la revisión de código). Un revisor de IA no sabe qué no quieres.
- Contexto de seguridad. Quién llama a ese endpoint, qué es público, qué dato es personal, a dónde van los logs y quién los lee. La IA ve un
console.log(order); no sabe queordertrae la dirección del cliente y que esos logs los lee más gente de la que debería.
Hay un problema más, de forma: el revisor de IA reporta con el mismo tono lo que comprobó y lo que supuso. Un hallazgo es una afirmación hasta que alguien lo demuestra con una entrada o una línea concreta. Y lee código, no lo ejecuta: lo que solo falla al correr lo atrapan tus pruebas y tu CI.
| Tipo de problema | ¿Está en el diff? | Quién lo atrapa |
|---|---|---|
| Caso sin manejar (null, vacío, límite) | Sí | IA, con la entrada que lo rompe |
| Prueba que falta o que no puede fallar | Sí | IA; la persona confirma |
| Nombre o comentario engañoso | Sí | IA |
| Formato y estilo | Sí | El linter, antes que nadie |
| Regla de negocio escrita en el repo | Si se la das | IA la contrasta; la persona decide |
| Regla de negocio no escrita | No | Persona |
| Si el cambio debería existir | No | Persona |
| Quién ve los datos y a dónde van | No | Persona |
Dos filtros: primero la IA, después una persona
El reparto que nos funciona tiene dos filtros en orden. Primero las máquinas: lint, tipos y pruebas en CI. Luego la revisión de IA con las instrucciones del repo. Quien escribió el cambio corrige cada hallazgo o responde por qué no aplica. Después revisa una persona, y solo su aprobación desbloquea el merge.
El primer filtro no le quita trabajo a la persona: le cambia dónde pone la atención. Ya no busca el await que falta; lee los hallazgos y las respuestas, y gasta su tiempo en la regla del envío, en si el cambio debería existir y en a dónde van los datos. Sigue leyendo el diff completo, porque la IA también se equivoca y porque aprobar es responder por el cambio.
Desliza la figura para verla completa
Un comentario de la IA nunca cuenta como aprobación. En GitHub lo haces explícito con un archivo CODEOWNERS y una regla de protección de rama con «Require review from Code Owners» (documentación de code owners). Así, las rutas donde viven las reglas de negocio no se fusionan sin una persona que las conoce:
# .github/CODEOWNERS
# Rutas que siempre necesitan a una persona que conoce las reglas.
# Cambia @tu-usuario por un usuario o equipo con permiso de escritura.
/lib/shipping.js @tu-usuario
/lib/payments/ @tu-usuario
/db/migrations/ @tu-usuario
/middleware.ts @tu-usuario
/.github/revision-ia.md @tu-usuario
/.github/CODEOWNERS @tu-usuario
- Las líneas con
#son comentarios. GitHub busca el archivo en.github/, en la raíz y endocs/, en ese orden, y usa el primero. - Cada línea es un patrón y uno o más dueños. La
/inicial ancla la ruta a la raíz:/middleware.tsno cubreapp/middleware.ts. /lib/payments/con/final cubre todo lo que hay dentro, a cualquier profundidad. Lo comprobamos con el mismo motor de patrones de git: cubrelib/payments/stripe/x.jsy nosrc/lib/payments/./db/migrations/y/middleware.ts: cambios de esquema y la puerta de entrada de cada petición.- Las dos últimas líneas protegen las instrucciones del revisor y el propio
CODEOWNERS: si alguien, o un agente, afloja las reglas, también lo aprueba una persona.
Detalles de la documentación que conviene saber: las rutas distinguen mayúsculas, ! y los rangos con [ ] no funcionan, la última línea que coincide gana, y el dueño necesita permiso de escritura o no se le asigna. Lo que no tiene dueño lo puede aprobar cualquiera con permiso de escritura.
Desliza la figura para verla completa
Darle contexto al revisor
La regla del envío está en la columna de «se le pasa» solo porque nadie se la dio. Si está escrita en el repo, el revisor de IA puede contrastar el diff con ella. Por eso las instrucciones viven en un archivo versionado, .github/revision-ia.md, y no en un mensaje que se escribe distinto cada vez:
# Instrucciones para la revisión con IA
Revisas un diff antes que una persona. Reporta; no corrijas.
## Revisa
- Errores que puedas demostrar con una entrada: null, lista vacía, 0, negativos, el valor límite.
- Qué pasa cuando una llamada falla o no devuelve nada.
- Nombres que dicen algo distinto de lo que hace el código.
- Ramas nuevas sin prueba y pruebas que pasarían aunque el código estuviera mal.
- Secretos, tokens o datos personales en código, logs o fixtures.
## Reglas de negocio de este repo
- Envío gratis desde 999 MXN de subtotal DESPUÉS de descuentos.
- Un pedido pagado no se edita: se reembolsa o se crea otro.
- No se escriben en logs correos, teléfonos ni direcciones.
## No juzgues
- Formato y orden de imports: lo revisa el linter.
- Si la función debería existir: lo decide una persona.
## Formato
Una línea por hallazgo: ruta:línea · bloquea | pregunta | menor · qué falla · entrada que lo demuestra.
Si no estás seguro, escribe "no seguro" y qué necesitarías saber.
Si no encuentras nada, escribe "sin hallazgos" y lista lo que no revisaste.
- La primera instrucción fija el papel: revisa antes que una persona y no edita. Un revisor que corrige mezcla dos trabajos y te deja un diff que nadie revisó.
- Revisa lista lo mecánico, y cada punto pide algo comprobable: una entrada, una rama, una prueba.
- Reglas de negocio mueve parte de la columna de la persona a la de la IA. Solo funciona con reglas cortas que se puedan contrastar con código; lo que necesita una conversación no cabe aquí.
- No juzgues evita ruido: el formato ya lo cubre el linter, y la decisión de producto no es suya.
- Formato obliga a dar ruta, línea y la entrada que demuestra el fallo. Un hallazgo sin entrada es una sospecha, y así se ve.
- Las dos últimas líneas cambian el silencio por información: «sin hallazgos» con la lista de lo que no se revisó le dice a la persona dónde mirar.
Con este archivo, el revisor sí puede señalar que la función compara el subtotal antes del cupón. La persona sigue decidiendo si la regla es esa, porque las reglas cambian y el archivo puede estar desactualizado. Para el resto del contexto que conviene darle a un agente, lee qué contexto darle a un agente de IA; si el cambio salió de una especificación, pásasela también al revisor (cómo escribir una especificación para un agente).
Cuándo no aprobar
La guía de Google pide aprobar cuando el cambio mejora con claridad la salud del código aunque no sea perfecto, y no aprobar nunca uno que la empeora, salvo una emergencia. Con IA en el primer filtro, estas son las señales para no aprobar todavía:
- No puedes explicar con tus palabras qué hace el cambio y por qué.
- Hay un hallazgo marcado «bloquea» sin corrección ni respuesta.
- El cambio toca una ruta protegida y su dueño no lo ha revisado.
- Una prueba cambió su valor esperado, se saltó o se borró sin una razón escrita. Si el código lo escribió un agente, revisa esto primero: el agente pasó los tests porque los borró.
- La descripción no dice qué regla de negocio aplica, y el cambio toca dinero, inventario o datos personales.
- La IA respondió «sin hallazgos» sin decir qué no revisó.
- El cambio mezcla un refactor con un cambio de comportamiento, y no puedes ver cuál línea hace qué.
Da igual qué agente escribió el cambio o qué modelo lo revisó: el criterio para aprobar es el mismo. Si estás eligiendo agente, compáralos con tu propio código (dos agentes con el mismo bug), pero no relajes la revisión porque uno te dio mejores resultados.
Errores comunes
- Contar el comentario de la IA como aprobación. Sin regla de protección de rama, alguien termina fusionando con «la IA no encontró nada».
- Darle solo el diff. Sin las reglas del repo, la IA revisa un código sin negocio, y la regla del envío pasa.
- Pedirle que corrija mientras revisa. Te devuelve un cambio nuevo que nadie revisó.
- Aceptar hallazgos sin entrada. Si no dice con qué valor falla, compruébalo antes de cambiar código.
- Que la persona repita lo mecánico y se salte lo demás. El valor del segundo filtro está en las reglas, las decisiones y los datos.
- Dejar sin dueño el archivo de instrucciones. Quien lo edite puede quitar la regla que estorba.
- Usar la IA en lugar de pruebas. Lee código; lo que solo falla al ejecutarse lo atrapan las pruebas y el CI.
Preguntas frecuentes
¿La revisión con IA reemplaza a la revisión de una persona?
No. Cubre bien lo mecánico y deja más tiempo para lo que no está en el código. La aprobación final, y la responsabilidad por el cambio, siguen siendo de una persona que conoce las reglas del negocio.
¿Qué le pongo en el archivo de instrucciones?
Qué revisar con criterios comprobables, las reglas de negocio cortas que se puedan contrastar con código, qué no juzgar y un formato de salida con ruta, línea y la entrada que demuestra el fallo.
¿Y si trabajo solo y no hay otra persona?
Haz tú el segundo filtro, pero en otro momento: deja el cambio, vuelve más tarde y revisa con la lista de la persona, no con la de la IA. Leer las reglas en voz alta contra el diff atrapa lo que se escapó al escribir.
¿Qué hago cuando la IA y la persona no están de acuerdo?
Pide la entrada que demuestra el hallazgo. Si existe, se corrige. Si es una regla o una decisión, manda la persona; si la regla cambió, actualiza el archivo de instrucciones en el mismo cambio.
Checklist
- Lint, tipos y pruebas corren antes de la revisión de IA.
- El revisor de IA lee un archivo de instrucciones versionado, con las reglas de negocio cortas.
- Cada hallazgo trae ruta, línea y la entrada que lo demuestra.
- Cada hallazgo «bloquea» tiene corrección o respuesta antes de pedir revisión humana.
- La persona revisa reglas, decisiones y datos, y lee el diff completo.
CODEOWNERSy la protección de rama exigen una persona en las rutas sensibles.- El archivo de instrucciones y
CODEOWNERStienen dueño. - No apruebas lo que no puedes explicar.
Para que el diff que llega a revisión sea pequeño y se pueda leer, trabaja con ramas y commits cortos: git para trabajar con agentes de IA.
¿Viste esto en Instagram? Todas las guías de los Reels están en ecomlabs.dev/guias.
Escrito por

Publicado el 19 de noviembre de 2026 · actualizado el 20 de noviembre de 2026