A primera vista, la receta para lograr código de IA de calidad parece obvia: escribe un prompt de sistema largo, divide la tarea en pasos y revisa el diff a ojo. En un par de funciones pequeñas eso aguanta. Pero en un repositorio activo en producción, la revisión manual se convierte rápido en un cuello de botella: el agente produce código más rápido de lo que tardas en abrir la pestaña del pull request.
En Anthropic lo vivieron de frente: cerca del 90% del código del propio Claude Code ya lo escribe y lo revisa Claude. Sin verificación automática, un ingeniero maneja como mucho una o dos sesiones en paralelo, porque todo depende de su atención. Con un buen circuito de verificación, esa misma persona ejecuta decenas o cientos de agentes en paralelo sin problemas.
Por qué los prompts tocaron techo y el peligro de las pruebas inestables
En mediciones internas de Anthropic sobre generación de archivos estructurados, añadir un evaluador independiente basado en rúbrica elevó la tasa de éxito en 10 puntos porcentuales. La mayor mejora ocurrió en los casos más difíciles, donde ajustar el prompt ya no daba resultado.
El código de pruebas tiene otra ventaja enorme: un test o benchmark escrito por un agente pasa a ejecutarse como software determinista normal. Puedes correr el script mil veces y obtener respuesta casi sin gastar tokens.
Pero aquí es fácil caer en dos trampas. La primera son las pruebas inestables o intermitentes (flaky tests), que sobre el mismo código a veces pasan y a veces fallan por tiempos de espera o condiciones de carrera. A un programador humano le desesperan, pero a un agente lo arruinan: tras un par de fallos aleatorios, el modelo aprende simplemente a relanzar la ejecución en lugar de corregir el bug.
En el repositorio de Claude Code son estrictos con esto: el agente tiene prohibido omitir pruebas inestables, meter sleep o repetir intentos hasta ver verde. Si no logra encontrar la causa, la prueba se elimina con una explicación por escrito. La segunda trampa son las suites lentas, que alargan el ciclo de retroalimentación e inflan el tamaño de cada lote de cambios. Los conjuntos pesados se mueven a la etapa previa al commit, dejando solo comprobaciones rápidas en el ciclo de trabajo.
Tres tipos de pruebas que le dan ojos al agente y atacan sus puntos ciegos
Las pruebas unitarias con mocks suelen dar una falsa sensación de seguridad: todo marca verde, pero la aplicación falla en el primer clic. Por eso el equipo prioriza las pruebas de extremo a extremo (End-to-End o E2E), que recorren el camino real del usuario de principio a fin.
Para que el agente vea el fallo real, le entregan «manos y ojos» en el entorno de ejecución. En web conectan Chrome DevTools Protocol y la extensión Claude para Chrome; en móviles instalan servidores MCP para iOS y Android; en escritorio habilitan el control de pantalla; y para backend levantan un arnés local de API.
Comparación entre la prueba unitaria checkout.test.ts con un timeout ciego y la prueba E2E checkout.spec.ts con captura de error y traza de pasos (Fuente: blog claude.dev)
La diferencia se nota al instante. La prueba unitaria checkout.test.ts cae con un escueto Error: Timeout after 30s: sin paso ni traza, el agente empieza a adivinar a ciegas. La prueba E2E checkout.spec.ts desglosa el recorrido paso a paso: el registro y el carrito pasaron, pero todo se detuvo en el pago. Junto a la traza hay una captura que muestra un aviso de que el formulario de pago no cargó y el botón de compra quedó desactivado. Con esa evidencia, el modelo corrige el error de inmediato.
La segunda capa son las pruebas basadas en propiedades (property-based testing). Cuando la IA escribe sus propios casos de ejemplo, suele fallar en los mismos puntos ciegos donde cometió el error en el código. Aquí defines una regla general (un invariante) y la librería alimenta la función con miles de entradas aleatorias: fast-check en JS/TS, Hypothesis en Python o proptest en Rust. Normalmente verifican cuatro propiedades: ida y vuelta (round-trip al codificar y decodificar), invariantes, idempotencia (idempotency, donde repetir una operación como una migración o reintento de pago da el mismo resultado) y equivalencia entre dos implementaciones.
import fc from "fast-check";
import { encodeSession, decodeSession } from "./session";
// Verificamos que la codificación no pierda datos con ninguna entrada
test("session round-trip preserves payload", () => {
fc.assert(
fc.property(
fc.record({
id: fc.uuid(),
messages: fc.array(fc.string()),
}),
(session) => {
const restored = decodeSession(encodeSession(session));
expect(restored).toEqual(session);
}
)
);
});
Quince líneas de código pasan por el analizador arreglos vacíos, Unicode corrupto y cadenas gigantes que el agente nunca habría pensado probar. Si la librería encuentra un caso que rompe la regla, lo reduce automáticamente al ejemplo mínimo.
La tercera capa es el testing diferencial (differential testing). Durante una migración o refactorización grande, el sistema antiguo se mantiene como referencia: las mismas peticiones van a ambas versiones y un script detecta cualquier diferencia en las respuestas.
Flujo operativo: skill /verify, tres intentos y lista de control de 39 incidentes
En la práctica, todo esto se empaqueta en un ritual diario dentro del repositorio. Las versiones recientes de Claude Code incluyen los comandos integrados /run, /verify y /run-skill-generator, y las reglas del proyecto se guardan en .claude/skills/verify/SKILL.md (más detalles en la documentación de skills). A diferencia de CLAUDE.md, que se carga siempre, las skills siguen el estándar Agent Skills y se cargan bajo demanda sin llenar el contexto.
---
name: verify
description: Build, launch, and smoke-test the running app E2E.
---
1. Start local service (`npm run dev`), wait for 200 on `/health`.
2. Run E2E flow against live app via CDP, Playwright, or API harness.
3. Save screenshots and step traces on failure; skip unit-only fallback.
4. After 3 failed fix rounds, stop and escalate to a human with traces.
El límite de tres rondas de corrección actúa como fusible. Si la prueba no pasa tras tres intentos, el agente debe detenerse y escalar a una persona con la traza reciente. De lo contrario, la red neuronal puede dar vueltas durante horas quemando tokens sin avanzar.
Luego el diff pasa por una lista de verificación de fiabilidad de 39 puntos. Cada punto tiene un disparador, una comprobación y un enlace a un fallo pasado. Por ejemplo, la regla sobre cargar conversaciones antiguas con la bandera --resume permanece inactiva si solo editas botones, pero en cuanto el diff toca el almacenamiento de sesiones o los tipos de mensajes, Claude verifica la compatibilidad del campo nuevo con los registros antiguos. En un PR normal se activan entre 3 y 10 puntos de los 39, sin ruido innecesario.
La revisión la conduce un único agente en varias rondas acumulativas, recordando observaciones previas. Si aun así un error llega a producción, no crean una regla nueva por impulso: esperan a que se repita en 2 o más PR, tres agentes oponentes intentan refutarla, se repite el incidente con tres buscadores de bugs y recién entonces una persona da el visto bueno. Los archivos .md que crecen demasiado se limpian periódicamente.
Prohibido editar sus propias pruebas: REVIEW.md, hooks, /goal y commit gate
Toda la defensa se viene abajo si permites que el agente modifique las reglas del examen para aprobar su código. Por eso el equipo aplica una prohibición férrea: ningún cambio en un PR puede editar sus propias comprobaciones. El servicio gestionado Claude Code Review sigue cuatro pasos (Find → Verify → Rank → Post), asigna etiquetas Important, Nit o Pre-existing y lee siempre REVIEW.md desde la rama base, nunca desde el propio pull request. Cada revisión queda vinculada a un commit concreto.
Para que los controles no dependan de la memoria del modelo, sobre las skills colocan hooks deterministas en .claude/settings.json (el comando /hooks muestra las reglas activas y la sintaxis está en la guía de hooks). Se disparan de forma invariable ante los eventos PreToolUse, PostToolUse, Stop y Notification.
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "jq -r '.tool_input.file_path' | xargs npx prettier -w"
}
]
}
],
"Stop": [
{
"matcher": "",
"hooks": [
{
"type": "command",
"command": "npm run lint && npm test"
}
]
}
]
}
}
Tras cada edición de archivo el hook formatea el código, y al terminar el turno ejecuta el linter y las pruebas. Para tareas largas activan el comando /goal: un modelo verificador independiente mantiene al agente iterando hasta que la condición verificable se cumpla con honestidad.
/goal All E2E checkout tests and linters pass without editing test assertions
La última barrera antes de grabar en Git es el commit gate, un filtro que comprueba si se ejecutó /verify o /code-review y estampa en cada commit el método de verificación usado (incluido un honesto "none"). Prueba en el simulador de abajo cómo funcionan sus tres modos y el desbloqueo automático tras dos rechazos en una sesión.
Simulador de commit gate: modos de control y protección contra bucles
Conviene activar la barrera primero en modo observe: recoges estadísticas de falsas alarmas, limpias el ruido y recién después pasas a enforce. Dejar pasar el commit tras dos bloqueos en la misma sesión evita que una prueba rota paralice un arreglo urgente, aunque el commit queda marcado honestamente con "none".
En cuanto a disponibilidad según el análisis en claude.dev, el reparto es claro. Las skills .claude/skills/, los comandos integrados /verify y /code-review, los hooks en settings.json, CLAUDE.md y /goal están disponibles para todos los usuarios de Claude Code. El servicio gestionado en GitHub Claude Code Review (niveles Quick, Standard, Deep y lectura de REVIEW.md desde la rama base) solo está abierto en los planes Team y Enterprise, no compila ni ejecuta código (solo inspecciona el diff y los archivos cercanos) y no está disponible para organizaciones con Zero Data Retention (ZDR), HIPAA/BAA o CMEK activados.



