Saltar al contenido

El agente de IA pasó los tests… porque los borró

En la práctica/ 20 min de lectura

Un agente de IA puede dejar la suite en verde saltando un test, cambiando el valor esperado o aflojando un mock. Tres revisiones, y un hook y un paso de CI probados.

  • IA
  • Claude Code
  • QA
En este artículo (8)
  1. Cómo un agente de IA «arregla» una prueba sin arreglar el código
  2. Revisión 1: tests borrados o saltados
  3. Revisión 2: valores esperados que cambiaron
  4. Revisión 3: mocks que aceptan cualquier cosa
  5. La regla en tus instrucciones y cómo reforzarla con un hook o un paso de CI
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

Para revisar código de agentes de IA no basta con ver la suite en verde: primero mira qué cambió en los tests. Un agente puede pasar las pruebas sin arreglar nada si salta o borra un test, cambia el valor esperado o pone un mock que acepta cualquier cosa. Revisa esas tres señales en el diff.

Lo vemos con un proyecto pequeño en Vitest: un bug real, sus pruebas y tres «correcciones» que dejan todo en verde sin tocar el bug, con la salida real de cada una. Después, la regla para tu CLAUDE.md o AGENTS.md, un hook de Claude Code que la hace cumplir y un paso de CI para lo que el hook no ve. Todo parte de tener un diff que revisar: si todavía no trabajas así, empieza por git para trabajar con agentes de IA.

Cómo un agente de IA «arregla» una prueba sin arreglar el código

«Haz que pasen los tests» es una meta que se cumple de dos formas: cambiar el código para que haga lo que la prueba exige, o cambiar la prueba para que exija lo que el código ya hace. Las dos dejan la suite en verde, y el resumen de Vitest no dice cuál de las dos ocurrió.

El proyecto de ejemplo calcula el total de un pedido con cupón y envío, gratis desde 1,000 (los montos van en centavos). Este es src/total.js, con el bug:

import { quoteShipping } from "./shipping.js";

export async function orderTotal(items, couponPercent = 0, quote = quoteShipping) {
  const subtotal = items.reduce((sum, item) => sum + item.price * item.qty, 0);
  const discount = Math.round((subtotal * couponPercent) / 100);
  const shipping = await quote(subtotal);
  return subtotal - discount + shipping;
}
  1. quoteShipping, de src/shipping.js, devuelve 0 desde 100000 y 9900 por debajo. orderTotal la recibe como tercer argumento opcional, para que las pruebas puedan pasar un mock.
  2. subtotal suma precio por cantidad y discount es el cupón redondeado al centavo.
  3. El bug es quote(subtotal): cotiza el envío antes del cupón. Un pedido de 1,100 con 20% de descuento queda en 880 y debería pagar envío, pero sale gratis.

Y estas son las pruebas, test/total.test.js. Hay dos más en test/shipping.test.js, seis en total:

import { describe, it, expect, vi } from "vitest";
import { orderTotal } from "../src/total.js";

const cart = [
  { price: 60000, qty: 1 },
  { price: 50000, qty: 1 },
];

describe("orderTotal", () => {
  it("charges shipping when the coupon leaves the order under 1,000", async () => {
    expect(await orderTotal(cart, 20)).toBe(97900);
  });

  it("quotes shipping on the subtotal after the coupon", async () => {
    const quote = vi.fn().mockResolvedValue(9900);
    await orderTotal(cart, 20, quote);
    expect(quote).toHaveBeenCalledWith(88000);
  });

  it("ships free when the discounted order is still 1,000 or more", async () => {
    expect(await orderTotal([{ price: 130000, qty: 1 }], 10)).toBe(117000);
  });

  it("charges shipping on a small order without a coupon", async () => {
    expect(await orderTotal([{ price: 50000, qty: 1 }])).toBe(59900);
  });
});
  1. La primera aplica un cupón de 20% al pedido de 1,100: 880 más 99 de envío dan 97900.
  2. La segunda pasa un mock con vi.fn().mockResolvedValue(9900) y comprueba con toHaveBeenCalledWith(88000) que el envío se cotizó con el cupón ya aplicado.
  3. La tercera y la cuarta cubren casos que hoy funcionan.

Con el bug, npx vitest run termina con código 1: Tests 2 failed | 4 passed (6), con expected 88000 to be 97900 en la primera prueba y un mock llamado con 110000 en vez de 88000 en la segunda. Eso es lo que le das al agente.

el diff del agente: tres formas de fingir el verde1 · test saltado- it("quotes shipping on the subtotal…+ it.skip("quotes shipping on the subtotal…Tests 4 passed | 2 skipped (6)no corre, así que no puede fallar2 · valor esperado cambiado- expect(…).toBe(97900);+ expect(…).toBe(88000);Tests 6 passed (6)ahora el test exige el bug3 · mock que acepta cualquier cosa- …toHaveBeenCalledWith(88000);+ …toHaveBeenCalledWith(expect.anything());Tests 6 passed (6)pasa con el bug y sin éllas tres dejan la suite en verdey src/total.js sigue cotizando el envío sobre el subtotal sin cupón

Desliza la figura para verla completa

Probamos tres «correcciones», cada una por separado y sin tocar src/total.js, y luego las corrimos contra el arreglo real:

Cambio en los testsCon el bugCon el arreglo real
it.skip en las dos que fallan4 passed | 2 skipped (6)Siguen saltadas: no comprueban nada
Borrar esas dos pruebas4 passed (4)Nada vuelve a comprobar ese caso
Valores esperados cambiados a 88000 y 1100006 passed (6)2 failed | 4 passed (6): la prueba exige el bug
Mock fijo y expect.anything()6 passed (6)6 passed (6): pasa con el bug y sin él
Ninguno: arreglar src/total.js—6 passed (6)

Revisión 1: tests borrados o saltados

Es la primera que haces y la más fácil de automatizar: antes de leer el código, mira qué archivos de test cambiaron y si alguno desapareció. En la rama de nuestro ejemplo, donde el agente saltó dos pruebas y borró test/shipping.test.js:

$ git diff --stat main...fix-cheat
 test/shipping.test.js | 10 ----------
 test/total.test.js    |  4 ++--
 2 files changed, 2 insertions(+), 12 deletions(-)
$ git diff --diff-filter=D --name-only main...fix-cheat
test/shipping.test.js
  1. git diff --stat main...fix-cheat lista lo que cambió la rama desde que salió de main. Un archivo de test con solo signos - es la primera alarma.
  2. --diff-filter=D --name-only deja solo los archivos borrados.

Si el agente no hizo commit, compara contra HEAD: git diff HEAD --stat. Sin HEAD, git diff compara con el índice, y lo que el agente borró con git rm ya salió del índice. En nuestra prueba, git diff --diff-filter=D --name-only no mostró nada y git diff HEAD --diff-filter=D --name-only sí mostró el archivo.

Luego busca los modificadores en el diff del archivo de test:

diff --git a/test/total.test.js b/test/total.test.js
index af548f5..0ff4470 100644
--- a/test/total.test.js
+++ b/test/total.test.js
@@ -9,3 +9,3 @@ const cart = [
 describe("orderTotal", () => {
-  it("charges shipping when the coupon leaves the order under 1,000", async () => {
+  it.skip("charges shipping when the coupon leaves the order under 1,000", async () => {
     expect(await orderTotal(cart, 20)).toBe(97900);
@@ -13,3 +13,3 @@ describe("orderTotal", () => {
 
-  it("quotes shipping on the subtotal after the coupon", async () => {
+  it.skip("quotes shipping on the subtotal after the coupon", async () => {
     const quote = vi.fn().mockResolvedValue(9900);
  1. Tras la cabecera, cada @@ abre un bloque; -U1 deja una sola línea de contexto.
  2. La línea - es la prueba original y la +, la misma con it.skip. El expect no cambió, y por eso el cambio parece mínimo.

El resumen lo dice si lo lees: 4 passed | 2 skipped (6). La documentación de test.skip lo presenta como la forma de no correr pruebas sin borrar su código: la prueba sigue ahí y no comprueba nada. Busca también .only, que salta las demás pruebas del archivo (3 passed | 3 skipped (6) en nuestro proyecto), y .todo. Borrar es peor: el resumen dice 4 passed (4) y solo lo notas si recuerdas que eran 6.

Vitest ayuda poco. allowOnly vale !process.env.CI por defecto, así que en CI un .only hace fallar la suite: con CI=true obtuvimos Unexpected .only modifier y código 1. passWithNoTests vale false: sin ningún archivo de test, Vitest sale con No test files found, exiting with code 1. Ninguna frena un .skip ni una prueba borrada entre otras.

Revisión 2: valores esperados que cambiaron

Esta no la detectan ni el hook ni el CI de este artículo, porque parece una corrección normal. El agente lee expected 88000 to be 97900 y cambia el número esperado por el que recibió:

diff --git a/test/total.test.js b/test/total.test.js
index af548f5..d8d61c0 100644
--- a/test/total.test.js
+++ b/test/total.test.js
@@ -10,3 +10,3 @@ describe("orderTotal", () => {
   it("charges shipping when the coupon leaves the order under 1,000", async () => {
-    expect(await orderTotal(cart, 20)).toBe(97900);
+    expect(await orderTotal(cart, 20)).toBe(88000);
   });
@@ -16,3 +16,3 @@ describe("orderTotal", () => {
     await orderTotal(cart, 20, quote);
-    expect(quote).toHaveBeenCalledWith(88000);
+    expect(quote).toHaveBeenCalledWith(110000);
   });
  1. toBe(97900) pasa a toBe(88000): el total sin envío, justo lo que produce el bug.
  2. toHaveBeenCalledWith(88000) pasa a toHaveBeenCalledWith(110000): el subtotal antes del cupón.

La suite queda en 6 passed (6), y lo grave viene después: cuando alguien arregla src/total.js, las dos pruebas fallan con expected 97900 to be 88000. La prueba ya no protege la regla de negocio; protege el bug.

Cada par -/+ dentro de un toBe, toEqual o toHaveBeenCalledWith necesita un motivo que no sea «así sale ahora». Pregunta de dónde sale el número nuevo y compáralo con la regla («envío gratis desde 1,000 después del cupón»). Si es el que el código ya devolvía, la prueba se ajustó al bug. Con los snapshots pasa igual: vitest -u («Update snapshot», según vitest --help) los reescribe con lo que el código produce hoy.

Revisión 3: mocks que aceptan cualquier cosa

La más difícil de ver: la prueba sigue ahí, corre y conserva su número esperado. Lo que cambia es lo que comprueba:

diff --git a/test/total.test.js b/test/total.test.js
index af548f5..509660f 100644
--- a/test/total.test.js
+++ b/test/total.test.js
@@ -10,3 +10,3 @@ describe("orderTotal", () => {
   it("charges shipping when the coupon leaves the order under 1,000", async () => {
-    expect(await orderTotal(cart, 20)).toBe(97900);
+    expect(await orderTotal(cart, 20, vi.fn().mockResolvedValue(9900))).toBe(97900);
   });
@@ -16,3 +16,3 @@ describe("orderTotal", () => {
     await orderTotal(cart, 20, quote);
-    expect(quote).toHaveBeenCalledWith(88000);
+    expect(quote).toHaveBeenCalledWith(expect.anything());
   });
  1. La primera prueba recibe vi.fn().mockResolvedValue(9900). Según la documentación de los mocks de Vitest, mockResolvedValue acepta un valor que se resuelve cuando se llama a la función: el envío vale 99 reciba el monto que reciba, y 880 más 99 dan 97900.
  2. En la segunda, expect.anything(), que según la documentación de expect coincide con todo excepto null o undefined, acepta el 110000 equivocado.

Resultado: 6 passed (6) con el bug y 6 passed (6) con el arreglo. Una prueba que pasa con el bug y sin él no prueba ese bug. expect.anything() tiene usos legítimos, pero en un diff que «arregla» una prueba que fallaba merece una pregunta, igual que un vi.mock nuevo, que reemplaza un módulo entero.

La comprobación más directa es correr las pruebas nuevas contra el código viejo. Con los cambios del agente sin commit:

git stash push -- src
npx vitest run
git stash pop
  1. git stash push -- src guarda los cambios de src/ y, según la documentación de git stash, devuelve solo esos archivos a HEAD: vuelve el bug y los tests quedan como los dejó el agente.
  2. npx vitest run corre la suite una vez y git stash pop devuelve el arreglo.

Con las pruebas del mock, la suite dio 6 passed (6) sin el arreglo; con las originales, 2 failed | 4 passed (6), que es lo que esperas. Si el arreglo creó archivos nuevos en src/, añade -u, porque git stash no guarda archivos sin seguimiento.

antes de aceptar el cambio del agentegit diff HEAD --stat¿tocó archivos de test?git diff HEAD --diff-filter=D --name-only¿borró archivos de test?git diff HEAD -- '*.test.*'¿.skip, .only o .todo nuevos?¿valores esperados o mocks?git stash push -- src && npx vitest runsin el arreglo, el test debe fallarluego: git stash popacepta el cambiosi algo falla: vuelve al agenteel verde no basta: revisa qué cambió en los testsHEAD incluye lo que el agente ya dejó en el índice con git add o git rm

Desliza la figura para verla completa

La regla en tus instrucciones y cómo reforzarla con un hook o un paso de CI

Las revisiones son para ti. La regla es para el agente: en sus instrucciones, para que no lo intente, y en un hook y en el CI, para cuando lo intente de todos modos.

La regla para CLAUDE.md o AGENTS.md

## Tests

- Nunca borres, saltes (.skip, .only, .todo, xit) ni debilites un test o un valor esperado para que la suite pase. Arregla el código.
- No cambies una comprobación real por un mock que acepta cualquier cosa (expect.anything(), un mock que ignora sus argumentos).
- Si un test te parece equivocado, detente y pregúntame antes de tocarlo. Explica por qué.
- Al terminar, lista cada archivo de test que cambiaste y por qué.
  1. Las dos primeras líneas nombran las trampas concretas, incluida la del mock, y la salida correcta: arreglar el código.
  2. Las dos últimas le dan una salida cuando el test de verdad está mal (detenerse y preguntar) y te dejan el informe que necesitas para revisar.

Según la documentación de memoria de Claude Code, el CLAUDE.md del proyecto va en ./CLAUDE.md o ./.claude/CLAUDE.md y se carga al empezar cada sesión. Si no hay ninguno, Claude Code lee AGENTS.md (desde la 2.1.277); si tienes los dos, importa el segundo con @AGENTS.md. Lo vimos en contexto para agentes de IA. La misma página marca el límite: Claude trata estos archivos como contexto, no como configuración que se hace cumplir, y para bloquear una acción remite a un hook PreToolUse.

Un hook PreToolUse que bloquea el cambio

Un hook PreToolUse corre antes de que la herramienta toque el archivo; si sale con código 2, la llamada se bloquea y Claude recibe el stderr como motivo. Es el mecanismo del hook que protege tu .env en Claude Code. Este va en .claude/hooks/guard-tests.mjs, en Node y sin dependencias:

// PreToolUse hook for Edit|Write: blocks changes that skip or remove tests.
// Exit 0 lets the tool run; exit 2 blocks it and Claude reads stderr.
import { existsSync, readFileSync } from "node:fs";

const { tool_name, tool_input } = JSON.parse(readFileSync(0, "utf8"));
const file = tool_input.file_path ?? "";

if (!/\.(test|spec)\.[^\\/]+$|[\\/]__tests__[\\/]/.test(file)) process.exit(0);

const before = tool_name === "Edit" ? tool_input.old_string : existsSync(file) ? readFileSync(file, "utf8") : "";
const after = tool_name === "Edit" ? tool_input.new_string : tool_input.content;

const SKIP = /\.(skip|skipIf|only|todo)\s*\(|\b(xit|xtest|xdescribe|fit|fdescribe)\s*\(/g;
const TEST = /(?<![.\w])[xf]?(it|test)(\.\w+)*\s*\(/g;
const count = (re, text) => (String(text ?? "").match(re) ?? []).length;

const problems = [];
if (count(SKIP, after) > count(SKIP, before)) problems.push("adds .skip, .only, .todo, xit or xdescribe");
if (count(TEST, after) < count(TEST, before)) problems.push("removes an it() or test() block");

if (problems.length) {
  console.error(
    `Blocked: this change to ${file} ${problems.join(" and ")}. ` +
      "Do not skip, delete or weaken a test to make it pass: fix the code. " +
      "If the test itself looks wrong, stop and ask the user.",
  );
  process.exit(2);
}
  1. Lee el JSON de stdin. Según la referencia de hooks, Edit trae file_path, old_string y new_string, y Write trae file_path y content. file_path llega absoluta, con barras invertidas en Windows: la expresión acepta \ y /.
  2. Si no es un archivo de test (*.test.*, *.spec.* o dentro de __tests__/), sale con 0.
  3. before y after son el texto antes y después: en un Edit, el fragmento viejo y el nuevo; en un Write, el archivo en disco y el contenido nuevo.
  4. SKIP busca .skip(, .skipIf(, .only(, .todo( y los alias de Jest (xit, xtest, xdescribe, fit, fdescribe), que Vitest 5.1 no exporta. TEST cuenta las llamadas a it( y test(, sin confundirlas con el .test( de una expresión regular.
  5. Si el cambio añade modificadores o deja menos pruebas, escribe el motivo en stderr y sale con 2.

Se registra en .claude/settings.json, que se versiona con el proyecto. Usamos la forma «exec» del ejemplo de Node de la referencia, sin shell de por medio:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "node",
            "args": ["${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-tests.mjs"]
          }
        ]
      }
    ]
  }
}
  1. "matcher": "Edit|Write" limita el hook a las dos herramientas que modifican archivos; con letras y |, son nombres exactos.
  2. command y args lanzan Node con el script, y Claude Code sustituye ${CLAUDE_PROJECT_DIR} por la raíz del proyecto.

Lo probamos pasándole JSON por stdin, con la forma que muestra la referencia: una edición que añade it.skip, el arreglo de src/total.js y el cambio de valor esperado de la revisión 2.

$ node .claude/hooks/guard-tests.mjs < edit-skip.json; echo "exit $?"
Blocked: this change to /home/ana/shop/test/total.test.js adds .skip, .only, .todo, xit or xdescribe. Do not skip, delete or weaken a test to make it pass: fix the code. If the test itself looks wrong, stop and ask the user.
exit 2
$ node .claude/hooks/guard-tests.mjs < edit-fix.json; echo "exit $?"
exit 0
$ node .claude/hooks/guard-tests.mjs < edit-expected.json; echo "exit $?"
exit 0
  1. La edición con it.skip sale con 2 y el mensaje que leería Claude; el arreglo en src/ sale con 0.
  2. El cambio de 97900 a 88000 también sale con 0: la revisión 2 sigue siendo tuya.

Con rutas de Windows, un Write que reescribe el archivo sin dos pruebas y un xdescribe en __tests__/ salieron con 2; una prueba nueva y un archivo de test nuevo, con 0. No lo corrimos dentro de una sesión de Claude Code. Y según la guía de hooks, el matcher Edit|Write no ve lo que Claude cambia con Bash o PowerShell: un rm test/shipping.test.js pasa de largo. Para eso está el CI.

Un paso de CI que compara con la rama base

El CI ve el resultado final, lo haya escrito quien lo haya escrito. scripts/check-tests.mjs compara la rama con el commit del que salió y falla si hay un archivo de test borrado, un modificador nuevo o menos pruebas:

// Fails when this branch deletes test files, adds .skip/.only/.todo, or has fewer
// tests than the commit it branched from. Usage: node scripts/check-tests.mjs origin/main
import { execFileSync } from "node:child_process";

const base = process.argv[2] ?? "origin/main";
const git = (...args) => execFileSync("git", args, { encoding: "utf8" }).trim();
const TESTS = ["*.test.*", "*.spec.*", "*__tests__/*"];
const SKIP = /\.(skip|skipIf|only|todo)\s*\(|\b(xit|xtest|xdescribe|fit|fdescribe)\s*\(/;
// vitest list --json prints one entry per test it would run (skipped and todo are left out).
const countTests = () =>
  JSON.parse(execFileSync(process.execPath, ["node_modules/vitest/vitest.mjs", "list", "--json"], { encoding: "utf8" })).length;

if (git("status", "--porcelain")) {
  console.error("Commit or stash your changes first: this script checks out the base commit.");
  process.exit(1);
}

const problems = [];
const deleted = git("diff", "--diff-filter=D", "--name-only", `${base}...HEAD`, "--", ...TESTS);
if (deleted) problems.push(`Deleted test files:\n${deleted}`);

const added = git("diff", "-U0", `${base}...HEAD`, "--", ...TESTS)
  .split("\n")
  .filter((line) => line.startsWith("+") && !line.startsWith("+++") && SKIP.test(line));
if (added.length) problems.push(`Added skip/only/todo:\n${added.join("\n")}`);

const branch = git("rev-parse", "--abbrev-ref", "HEAD");
const back = branch === "HEAD" ? git("rev-parse", "HEAD") : branch;
const headCount = countTests();
git("checkout", "--quiet", "--detach", git("merge-base", base, "HEAD"));
let baseCount;
try {
  baseCount = countTests();
} finally {
  git("checkout", "--quiet", back);
}
console.log(`Tests: ${baseCount} on ${base}, ${headCount} on this branch.`);
if (headCount < baseCount) problems.push(`Fewer tests: ${baseCount} -> ${headCount}`);

if (problems.length) {
  console.error(problems.join("\n\n"));
  process.exit(1);
}
console.log("OK: no test was deleted, skipped or lost.");
  1. TESTS son pathspecs de git, donde * también cruza carpetas: *.test.* encuentra test/total.test.js.
  2. countTests corre vitest list --json. Según la documentación de la CLI de Vitest, desde la versión 5 analiza los archivos sin ejecutarlos; en nuestras pruebas, las saltadas y las todo no salen en la lista. Llama a vitest.mjs con el mismo Node porque execFileSync no lanza npx en Windows sin shell (nos dio ENOENT, y EINVAL con npx.cmd).
  3. Con cambios sin commit se detiene, porque va a cambiar de commit.
  4. Los dos git diff buscan archivos de test borrados (--diff-filter=D) y líneas añadidas con un modificador (-U0 deja solo las líneas cambiadas).
  5. Cuenta en la rama, cambia al git merge-base, cuenta otra vez y vuelve; el finally vuelve aunque el conteo falle. Si encontró algo, sale con 1.

En el repositorio de prueba, la rama honesta, que solo arregla src/total.js, dio Tests: 6 on main, 6 on this branch., OK y código 0. La tramposa:

$ node scripts/check-tests.mjs main
Tests: 6 on main, 2 on this branch.
Deleted test files:
test/shipping.test.js

Added skip/only/todo:
+  it.skip("charges shipping when the coupon leaves the order under 1,000", async () => {
+  it.skip("quotes shipping on the subtotal after the coupon", async () => {

Fewer tests: 6 -> 2
  1. El conteo baja de 6 a 2, y aparecen el archivo borrado y las dos líneas con it.skip.
  2. El script terminó con código 1.

Las ramas con los valores esperados cambiados y con el mock suelto pasaron con 6 y 6: ningún conteo ve las revisiones 2 y 3. En GitHub Actions va antes de la suite, con el mismo esqueleto de Claude Code en GitHub Actions:

name: Tests

on:
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - uses: actions/setup-node@v7
        with:
          node-version: 22
      - run: npm ci
      - name: No deleted, skipped or lost tests
        run: node scripts/check-tests.mjs origin/${{ github.base_ref }}
      - run: npx vitest run
  1. fetch-depth: 0 le pide a actions/checkout todo el historial de todas las ramas y etiquetas; con el valor por defecto, 1, no habría base con la que comparar.
  2. npm ci instala Vitest. node_modules tiene que estar en .gitignore, o el script verá cambios sin commit.
  3. github.base_ref es la rama destino del PR; solo existe en pull_request y pull_request_target.

En un PR, el checkout queda en el commit de fusión de refs/pull/N/merge. Lo simulamos en local con un commit de fusión y HEAD desacoplado, con el mismo resultado. El YAML lo validamos como YAML; no lo corrimos en GitHub. Si quieres un filtro más antes de leer tú el diff, el subagente revisor de código en Claude Code puede revisarlo con esta misma lista.

cada señal del diff y qué hacer con ellaseñalcómo se vequé hacestest saltado.skip .only .todo xitquítalo y arregla el códigotest o archivo borrado--diff-filter=Drestáuralo y pide el motivovalor esperado cambiado97900 → 88000pide la regla de negociomock que acepta todoexpect.anything()exige los argumentos realestest y código juntosel mismo commitpruébalo sin el arreglolas filas 1 y 2 las frena un hook o el CIde la 3 a la 5 te toca a ti: un test que pasa con y sin el bug no lo prueba

Desliza la figura para verla completa

Errores comunes

  • Pedir «haz que pasen los tests». Pide el resultado: «arregla el bug del envío; no cambies los tests sin preguntarme».
  • Leer solo «passed». 4 passed | 2 skipped y 4 passed (4) también son verdes. Compara el total con el de antes.
  • Revisar con git diff sin HEAD. Lo que el agente pasó al índice con git add o git rm no aparece.
  • Aceptar test y código juntos sin probar el test contra el código viejo. Si pasa con el arreglo y sin él, no prueba el arreglo.
  • Confiar solo en el hook. No ve Bash ni PowerShell, ni puede juzgar un valor esperado.
  • Pasar --allowOnly o --passWithNoTests en CI para destrabar el pipeline. Son justo las opciones que frenan un .only o una suite vacía.

Preguntas frecuentes

¿El agente lo hace a propósito?

No necesitas saberlo para protegerte. «Que pasen los tests» se cumple igual cambiando el código o la prueba, y el resumen no distingue una cosa de la otra. La regla le quita esa salida; las revisiones, el hook y el CI la detectan si aun así la toma.

¿Y si el test de verdad estaba mal?

Pasa, y por eso la regla dice «detente y pregúntame» y no «nunca toques un test». El hook bloquea las ediciones de Claude, no las tuyas: si estás de acuerdo con su explicación, haz tú el cambio y deja el motivo en el commit.

¿Sirve con Jest u otro runner?

El hook sí, porque también busca los alias de Jest. En el script de CI, las comprobaciones de git valen para cualquier proyecto, pero el conteo usa vitest list --json: con otro runner, cambia countTests por el comando equivalente.

¿No basta con allowOnly en CI?

Solo cubre .only. Un .skip, un .todo o una prueba borrada pasan en CI sin aviso. Por eso el script cuenta las pruebas contra la rama base en vez de fiarse del resumen.

Checklist

  • Leíste git diff HEAD --stat (o main...rama) antes que el código.
  • Ningún test aparece en git diff HEAD --diff-filter=D --name-only.
  • No hay .skip, .only, .todo, xit ni xdescribe nuevos en git diff HEAD -- '*.test.*'.
  • El total de pruebas es el de antes o mayor, sin skipped nuevos.
  • Cada valor esperado que cambió tiene un motivo de negocio.
  • Ningún mock nuevo acepta cualquier argumento donde antes se comprobaba uno concreto.
  • Con git stash push -- src, las pruebas nuevas fallan; con el arreglo, pasan.
  • La regla está en CLAUDE.md o AGENTS.md, el hook en .claude/settings.json y el script en el CI.

Un agente que pasó los tests no es lo mismo que un agente que arregló el bug, y la diferencia está en el diff. Si todavía no trabajas con ramas y commits pequeños, empieza por git para trabajar con agentes de IA; para automatizar más, sigue con los hooks de Claude Code y Claude Code en GitHub Actions. Y si el agente ya hizo el cambio, puedes volver atrás sin tocar git: /rewind y los puntos de control de Claude Code.

¿Viste esto en Instagram? Comenta TRAMPA en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 2 de noviembre de 2026 · actualizado el 3 de noviembre de 2026

← Blog