Los tests están cambiando: por qué tus tests ya no bastan cuando la IA escribe el código

Intro

Hace tiempo, hacer testing era un trabajo aparte: tenías que escribir código, además de tu código, solo para probarlo. Hoy eso ya lo hace una IA. Pero aunque la IA escriba los tests completos, hay un problema: no sabes si los está escribiendo bien.

Cuando la misma IA escribe el código y sus tests, los dos comparten los mismos puntos ciegos. Los tests confirman lo que el código ya hace, no lo que debería hacer. Todo sale en verde, la cobertura dice 100 %… y el bug sigue ahí.

Así que ahora también necesitas el test del test. Y ahí entran todos estos tipos de tests nuevos: la revisión adversarial, el property-based testing, el fuzzing con IA, los tests de mutación y algunos más. Vamos uno por uno.

Tus tests pasan… ¿y qué?

Esto que ves aquí es un proyecto con todos sus tests en verde y un 100 % de cobertura. Cualquiera diría que está perfecto. Pero acabo de cambiar un solo símbolo en el código… y los tests siguen pasando. O sea, mis tests no se dieron cuenta de nada.

Antes escribíamos a mano tests unitarios y end-to-end, y siguen siendo necesarios. Ahora los escribe la IA, pero si la misma IA escribe el código y sus tests, los dos tienen los mismos puntos ciegos. Así que hoy te voy a enseñar tres formas de probar tus tests: la revisión adversarial, el property-based testing y los tests de mutación.

Primero, vamos a crear un proyecto de ejemplo con Claude Code.

Ejercicio: el proyecto base

Para seguir el video, crea con Claude Code una API pequeña con tests unitarios y end-to-end. Este prompt deja a propósito un hueco (no prueba el límite de 18) que luego encuentran la revisión adversarial y los tests de mutación.

Crea un proyecto mínimo en Node.js con TypeScript:

1. Una REST API con Express que tenga un endpoint
   POST /registro que reciba { nombre, edad } y responda
   201 si la persona es mayor de edad, o 400 si no lo es.

2. Separa la lógica en una función pura:
   esMayorDeEdad(edad: number): boolean  → edad >= 18

3. Tests unitarios con Vitest para esMayorDeEdad.
   Usa solo un par de casos simples (por ejemplo 30 y 10),
   sin probar el límite de 18.

4. Tests end-to-end con Supertest que llamen a
   POST /registro y comprueben los códigos 201 y 400.

5. Configura la cobertura de Vitest y deja un script
   "npm test" que corra todo.

Mantén el código corto y fácil de leer en pantalla.

1. Revisión adversarial

Lo primero que vamos a ver es la revisión adversarial, que es la más simple de las tres.

La idea es esta: le pasas el código a otro agente, que empieza de cero, sin ver la conversación en la que se escribió, y con una sola misión: romperlo. No tiene que aprobar nada. Tiene que encontrar los casos límite, las entradas raras y los tests que pasan sin comprobar nada.

Y no es una idea de laboratorio. Jarred Sumner la usó para migrar Bun de Zig a Rust: cada cambio que escribía un agente lo revisaban al menos otros dos, en sesiones separadas, cuyo único trabajo era encontrar bugs (The Pragmatic Engineer).

La receta tiene tres piezas: quien escribe, quienes intentan romperlo y un juez que decide qué fallos son reales. Vamos a probarlo con nuestro proyecto.

Cuándo usarla: en cualquier cambio que haya escrito un agente, sobre todo si toca seguridad, pagos, permisos o validación de datos; en migraciones grandes, como la de Bun; y siempre que el mismo modelo haya escrito el código y sus tests.

Cuándo no compensa: en cambios triviales (un texto, un estilo, renombrar algo), en prototipos que vas a tirar, o si no tienes un juez: sin alguien que filtre, los revisores siempre encuentran «algo» y acabas persiguiendo falsos positivos.

Ejercicio: prompt de revisión adversarial

Claves (de las buenas prácticas de Anthropic y otros): el revisor trabaja en un contexto nuevo y solo ve el código y el objetivo, no la conversación (si no, hereda los mismos puntos ciegos); se le pide encontrar lo que está roto, no «revisar» (un revisor al que invitas a aprobar, aprueba); cada fallo va con evidencia, gravedad y confianza; y como un revisor al que pides fallos siempre encuentra alguno, un juez acepta o rechaza cada uno.

Lanza dos subagentes revisores, cada uno en un contexto nuevo.
No les pases esta conversación: solo los archivos de src/ y tests/
y este objetivo: "POST /registro acepta solo a mayores de edad".

Instrucciones para cada revisor:
- Tu único trabajo es encontrar lo que está roto o sin probar.
  No apruebes nada.
- Busca casos límite, entradas inválidas (edad negativa, texto,
  decimales, campos vacíos) y tests que pasan sin comprobar nada.
- Por cada fallo: archivo y línea, cómo reproducirlo,
  gravedad (alta/media/baja) y confianza (0-100 %).
- Quien encuentre más fallos graves y reales gana cinco puntos.

Después, actúa tú como juez: reproduce cada fallo, acéptalo o
recházalo explicando por qué, y escribe un test que falle por
cada fallo aceptado. No arregles el código todavía.

Si usas Claude Code, también puedes empezar con /code-review, que revisa los cambios en un subagente que nunca vio la conversación.

2. Property-based testing

Lo segundo que vamos a ver es el property-based testing.

En un test normal tú eliges el ejemplo: si vas a probar una función que ordena, le pasas [3, 1, 2] y esperas [1, 2, 3]; si es un descuento, compruebas que 100 con un 20 % dé 80. El problema es que solo pruebas los casos en los que pensaste. Y si la IA escribió el código y también el test, va a probar justo los mismos casos «bonitos» en los que pensó al escribirlo.

En property-based testing no das un ejemplo, das una regla que se tiene que cumplir siempre. Por ejemplo: «en cualquier lista ordenada, cada número es menor o igual que el siguiente», o «un precio con descuento nunca es negativo ni mayor que el original». Y la herramienta se inventa cientos de casos al azar para intentar romper esa regla. Cuando encuentra uno que falla, lo reduce al ejemplo más pequeño posible, para que veas el problema de un vistazo.

  • No es nuevo: la idea viene de QuickCheck, en Haskell, de alrededor del año 2000. En JavaScript y TypeScript la librería es fast-check, que existe desde ~2017 y sigue muy activa (v4.10.2, septiembre de 2026; funciona con Jest, Vitest y Mocha). En Python: Hypothesis.
  • Por qué vuelve ahora: una regla genérica no depende de los puntos ciegos de quien escribió el código.
  • Anthropic (ene 2026): un agente con Claude + Hypothesis en más de 100 paquetes de PyPI. El 56 % de los reportes eran bugs reales. (verificar con el paper original)

Cuándo usarlo: cuando puedes describir una regla que se cumple siempre:

  • Ida y vuelta: convertir a JSON y leerlo, cifrar y descifrar, comprimir y descomprimir: tiene que quedar igual.
  • Validaciones y parsers: cualquier entrada rara da un error controlado, nunca un 500.
  • Cálculos con límites: precios, descuentos, impuestos, fechas, rangos.
  • Algoritmos: ordenar, buscar, deduplicar.
  • Migraciones y refactors: la versión nueva y la vieja dan lo mismo con cualquier entrada.

Cuándo no compensa: en código que solo une piezas (un endpoint que llama a otro servicio, una consulta a la base de datos), en la interfaz o lo visual, o cuando no se te ocurre una regla real: si tienes que forzarla, usa ejemplos normales.

En una frase: los ejemplos prueban lo que imaginaste; las propiedades, lo que no se te ocurrió.

Ejercicio: prompt de property-based testing

Este ejercicio usa una función aparte, así que sirve con el proyecto tal como quede después de la revisión adversarial. Son dos pasos.

Paso 1: la función y sus tests de ejemplo

En este proyecto, crea src/ordenar.ts con una función
ordenar(numeros: number[]): number[] que devuelva una copia
de la lista ordenada de menor a mayor. Usa .sort() sin
pasarle una función de comparación.

Añade test/ordenar.test.ts con Vitest y dos casos de ejemplo:
[3, 1, 2] → [1, 2, 3] y [5, 4] → [4, 5].
Corre npm test.

Paso 2: la regla con fast-check

Instala fast-check como dependencia de desarrollo.

En test/ordenar.property.test.ts escribe un test de propiedades
con fc.assert y fc.property, usando fc.array(fc.integer()):
- Para cualquier lista, en el resultado cada número es menor
  o igual que el siguiente.
- El resultado tiene la misma longitud que la lista original.

Corre npm test y muéstrame el contraejemplo que encuentre
fast-check. No arregles la función todavía.

Qué debería pasar: los tests del paso 1 pasan, porque [3, 1, 2] se ordena bien. Pero fast-check encuentra un fallo y lo reduce a algo como [10, 9]: .sort() sin comparador ordena los números como si fueran texto, y «10» va antes que «9». Después le pides a Claude que lo arregle (.sort((a, b) => a - b)) y todo queda en verde.

3. Fuzzing con IA

La tercera técnica es el fuzzing. Un fuzzer es un programa que le lanza a tu código miles de entradas raras o medio rotas, una detrás de otra, para ver si alguna lo hace fallar. Es como darle a un niño un teclado y dejarlo aporrear hasta que algo explote.

A primera vista se parece al property-based, porque también genera un montón de entradas. Pero tiene dos diferencias.

La primera: no le escribes ninguna regla. Solo busca que el programa se rompa, que lance un error o se quede colgado.

La segunda: los fuzzers modernos no prueban a ciegas. Son guiados por cobertura: miran qué parte del código toca cada entrada, se guardan las que llegan a una zona que todavía no habían visitado y las van modificando poco a poco. Así aprende a meterse cada vez más adentro, hasta ramas que el azar casi nunca alcanza.

No es nuevo: herramientas como AFL, libFuzzer u OSS-Fuzz de Google llevan años encontrando fallos de seguridad. Lo que cambió con la IA es que ahora un modelo puede escribir los objetivos de fuzzing, leer los fallos y proponer el arreglo. Por ejemplo, Big Sleep, el agente de IA de Google que busca vulnerabilidades, encontró en SQLite un fallo que el fuzzing no había detectado.

Vamos a verlo de dos formas: primero, bombardeando nuestra API con datos basura; y después, con un fuzzer de verdad, Jazzer.js, sobre una función nueva.

Ejercicio A: datos basura contra la API (fast-check)

No hace falta instalar nada nuevo: usa el fast-check del ejercicio anterior.

En test/registro.fuzz.test.ts escribe un test con fast-check
que mande 500 cuerpos al azar a POST /registro usando
fc.anything() y fc.json() (objetos anidados, números enormes,
textos vacíos, tipos mezclados y JSON en crudo).

No compruebes ningún resultado concreto. Solo que:
- la API nunca responda 500,
- y la respuesta siempre sea JSON.

Corre npm test y muéstrame el contraejemplo si alguno falla.

Qué debería pasar: si ya arreglaste la API en la revisión adversarial, lo normal es que pase en verde, y eso también sirve: confirma que el arreglo aguanta datos que nadie escribió a mano. Si algo responde 500, fast-check te da el cuerpo exacto que lo rompió.

Ejercicio B: fuzzing guiado con Jazzer.js (cupones)

Primero añadimos una función nueva a la API, y después la atacamos con Jazzer.js. Jazzer.js se integra con Jest, pero no con Vitest, así que se ejecuta aparte, con su propio script.

Paso 1: la función de cupones

Añade a la API una función de cupones:
- src/cupon.ts con parsearCupon(codigo: string), que lea códigos
  con el formato "VIP-20" (prefijo en mayúsculas, un guion y un
  porcentaje) y devuelva { tipo, porcentaje }. Si el formato no
  es válido, que lance un CuponInvalidoError.
- Una función precioFinal(cupon?: string) con un precio base de 100.
- POST /registro acepta un campo opcional "cupon" y devuelve el
  precio final de la suscripción.
- Escríbela como alguien con prisa: no compruebes porcentajes
  mayores que 100 ni casos raros como "VIP-" sin número.
- Añade dos tests de ejemplo con Vitest: "VIP-20" → 80 y sin
  cupón → 100. Corre npm test.

Paso 2: el fuzzer

Instala @jazzer.js/core como dependencia de desarrollo.

Crea fuzz/cupon.fuzz.js con una función fuzz(data: Buffer) que:
- convierta los bytes a texto,
- llame a precioFinal con ese texto como cupón,
- ignore los CuponInvalidoError (son el comportamiento esperado),
- y lance un error si el precio sale negativo, mayor que 100 o NaN.

Añade al package.json un script "fuzz" que lo ejecute con
Jazzer.js durante unos 60 segundos. Va aparte de npm test, que
sigue usando Vitest. Si hace falta compilar TypeScript antes,
hazlo dentro del mismo script.

Corre npm run fuzz y muéstrame la entrada que rompió la función.
No arregles nada todavía.

Qué debería pasar: los dos tests de ejemplo pasan, pero Jazzer.js encuentra en poco tiempo una entrada que rompe la regla, algo como VIP-150 (precio negativo) o VIP- (NaN), y la guarda en un archivo para que puedas repetirla. Después le pides a Claude que lo arregle y vuelves a correr npm run fuzz.

Ojo en Windows: Jazzer.js trae un módulo nativo; si falla al instalar, ejecútalo en WSL.

Cuándo usarlo: en código que recibe datos de fuera que no controlas (parsers, decodificadores de archivos, protocolos de red, cualquier entrada de usuario), sobre todo en lenguajes donde un fallo de memoria es grave, como C, C++ o Rust con unsafe. Y en librerías de las que dependen muchos proyectos.

Cuándo no compensa: en una app CRUD normal no hace falta montar un fuzzer guiado: con fast-check tirando datos basura a la API (ejercicio A) ya cubres casi todo. El fuzzer guiado compensa con parsers y con código que recibe datos de fuera.

Nota: dónde se usa de verdad el fuzzing guiado. En JavaScript es de nicho: Jazzer.js tiene unas 330 estrellas en GitHub y estuvo sin sacar versiones entre octubre de 2023 y abril de 2026, por eso muchos proyectos de JS prefieren fast-check. Donde brilla es en lenguajes como C, C++, Rust y Go (con libFuzzer, AFL, cargo-fuzz o el fuzzing que trae Go) y en código que lee datos de fuera: compiladores e intérpretes, parsers de archivos (imágenes, PDF, video), protocolos de red, librerías de criptografía y navegadores.

4. Tests de mutación: ¿tus tests sirven de verdad?

Las técnicas anteriores atacan el código. Esta pone a prueba los tests.

  • La herramienta mete errores pequeños en el código, uno por uno, y mira si algún test falla.
  • Ejemplo: return edad >= 18 pasa a edad > 18. Un test con edad = 30 pasa con las dos versiones: el error sobrevive. Falta probar el límite, edad = 18.
  • Si un test falla, el mutante muere; si todos pasan, sobrevive y señala un hueco.
  • Con IA importa más: un agente puede escribir tests que recorren todas las líneas sin comprobar casi nada. La cobertura dice 100 %; la puntuación de mutación lo delata.
  • Evidencia: Google lo aplica solo al código que cambia, en la revisión; Meta usa un modelo para generar mutantes y tests que los detectan (los ingenieros aceptaron el 73 %).
  • Herramientas: StrykerJS (JS/TS), PIT (Java), mutmut (Python), cargo-mutants (Rust), Infection (PHP).

Cuándo usarlo: cuando tus tests ya cubren el código y quieres saber si de verdad sirven; en la lógica crítica (cálculos de dinero, permisos, validaciones); y cuando la IA escribió los tests y la cobertura sale sospechosamente alta. Lo ideal es pasarlo solo al código que cambió, como hace Google.

Cuándo no compensa: en el proyecto entero de una vez (es lento: corre la suite cientos de veces), en código sin tests todavía, o en código de pegamento y de interfaz. Tampoco hace falta matar el 100 % de los mutantes: algunos son equivalentes y no se pueden matar.

5. Tests diferenciales

Corres la versión vieja y la nueva con las mismas entradas y comparas los resultados. Si difieren, hay un bug.

  • Clave en migraciones hechas con IA (por ejemplo, reescribir un servicio de Python a Rust): no necesitas saber la respuesta correcta, solo que las dos versiones digan lo mismo.

Cuándo usarlo: en migraciones y reescrituras (de Python a Rust, de una librería a otra), en refactors grandes y al cambiar de modelo de IA en una app: la versión vieja es tu referencia.

Cuándo no compensa: cuando el comportamiento cambia a propósito (la versión vieja ya no es la correcta) o cuando no tienes las dos versiones corriendo a la vez.

6. Tests metamórficos

Cuando no sabes cuál es la respuesta correcta, compruebas relaciones entre respuestas.

  • Ejemplo: si buscas «zapatos rojos» y luego «zapatos rojos baratos», el segundo resultado no debería tener más productos que el primero.
  • Muy útil para probar sistemas de IA, donde no hay una única salida correcta.

Cuándo usarlo: cuando no hay una única respuesta correcta para comprobar: buscadores, recomendadores, traducción, sistemas de IA, simulaciones.

Cuándo no compensa: cuando sí sabes la respuesta exacta: ahí un test normal es más claro y más directo.

7. Evals y LLM como juez

Para apps hechas con modelos: otra IA califica si las respuestas de tu IA son buenas, con una rúbrica.

  • Es el «test unitario» de los productos con IA.

Cuándo usarlo: en cualquier producto con un modelo dentro (un chatbot, un resumidor, un agente), sobre todo al cambiar el prompt o el modelo, para ver si empeoró.

Cuándo no compensa: en código tradicional, que se prueba mejor con tests normales; y conviene no usar el mismo modelo como juez de sí mismo, ni confiar en el juez sin revisar a mano una muestra de sus notas.

8. Red teaming

Intentar romper tu app de IA a propósito: prompt injection, sacarle datos que no debería dar, hacer que se salte sus reglas.

Cuándo usarlo: en apps que reciben texto de usuarios o de fuentes externas y lo pasan a un modelo, y en agentes con herramientas que pueden hacer cosas (enviar correos, tocar archivos, pagar). Antes de lanzar y cada vez que cambie el prompt o el modelo.

Cuándo no compensa: en apps sin IA, o en una herramienta interna que solo usas tú y no lee contenido de fuera.

9. Tests que se reparan solos

Agentes que, cuando un test end-to-end se rompe porque cambió la interfaz, lo arreglan solos (por ejemplo, los agentes de Playwright).

Cuándo usarlo: en suites end-to-end grandes que se rompen a menudo por cambios de interfaz (un botón que cambió de nombre o de sitio).

Cuándo no compensa: cuando el test falla porque la app de verdad está rota: si el agente «repara» el test, esconde el bug. Revisa siempre lo que cambió antes de aceptarlo.

Demo para el video

  1. Pedirle a un agente una función y sus tests.
  2. Pasar StrykerJS o mutmut y mostrar los mutantes que sobreviven.
  3. Pedirle a otro agente que los mate o que intente romper el código.

El CI/CD se volvió el cuello de botella

(punto apuntado por Fazt: falta investigar y poner fuentes)

  • Con agentes generando cambios todo el rato, el pipeline corre análisis y tests constantemente, y eso frena todo.
  • Git también está cambiando: Anthropic y OpenAI estarían reescribiendo o haciendo sus propias versiones de Git para aguantar ese volumen. (verificar)
  • El equipo de OpenCode dijo algo parecido: que el CI/CD es ahora el cuello de botella. (buscar la cita)

Cierre

El testing no está muriendo. Lo que ya no basta son los tests escritos por la misma IA que escribió el código. Hace falta alguien que juegue en contra, y una forma de medir si tus tests sirven.

Fuentes