> ## Content Index
> Fetch the complete content index at: https://cesarbeassuarez.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# De 8 tests por día a 150
- URL: https://cesarbeassuarez.dev/de-8-tests-por-dia-a-150/
- Published: 2026-10-25T18:55:13.000Z
- Updated: 2026-10-26T00:22:48.000Z
- Description: Pasé de automatizar 8 tests por día a 150 con agentes en paralelo. Qué construí para que ese ritmo no fuera una fábrica de tests inútiles.
- Author: César Beas Suárez
- Tags: QA Estratégico, IA aplicada al testing, #destacado

Hace unos años me pedían automatizar dos Gherkin por día. Según cuántos escenarios tuviera cada uno, eso daban 8 o 10 tests. Era el ritmo normal y nadie lo discutía.

Hoy, en una jornada con agentes en paralelo, termino cerca de 150\. Al día siguiente reviso la corrida, leo el log, pulo detalles y reporto lo que aparece. Contando los dos días, son unos 75 tests por día.

Este post es sobre qué cambió exactamente, qué tuve que construir para que ese ritmo no fuera una fábrica de tests inútiles, y dónde se me mudó el problema.

---

## El salto no fue "usar IA"

Esto es lo que más me sorprendió cuando miré para atrás.

Hacía rato que usaba IA para escribir tests. Una sesión abierta en el editor, le pedía un spec, lo revisaba, lo corregía. Ayudaba, sí. Pero el orden de magnitud no se movía: seguía en el mismo rango de siempre, tal vez un poco más arriba.

El cambio fue pasar a **agentes en paralelo desde la terminal**. Cada uno en su propio worktree, con su rama, trabajando en una tarjeta distinta al mismo tiempo. Ahí el número se multiplicó.

La diferencia es simple: con una sesión, el cuello de botella soy yo esperando que termine. Con siete, mientras uno espera un device, otro está escribiendo, otro está corriendo y otro me pide que revise una propuesta. Yo paso de escribir a decidir.

---

## Entonces, ¿qué hago yo?

Antes de que un agente escriba una línea, el trabajo es mío.

Para cada tarjeta armo un mapa. Parto la funcionalidad en piezas de negocio y las paso por una matriz que las valora por riesgo: qué pasa si eso falla, y qué tan probable es que falle. Alto es plata mal calculada, un comprobante mal emitido, stock o saldo mal grabados. Bajo es algo visual o informativo.

![Una tarjeta entra a una matriz que la valora por impacto y probabilidad y elige la técnica de prueba. De ahí sale un plan que se reparte en un plan por agente, hasta siete.](https://cesarbeassuarez.dev/content/images/2026/10/diagrama-de-la-tarjeta-al-plan-de-cada-agente.png)

El plan sale antes que el código. La matriz es donde entra mi criterio.

Con el riesgo en la mano, la matriz elige la técnica que corresponde a cada pieza: partición y valores límite si hay un rango o un tope, tabla de decisión si hay condiciones combinadas, transición de estados si el comportamiento depende de la secuencia.

De ahí sale un plan. Y de ese plan salen varios: uno por agente, con lo que le toca a cada uno.

Recién ahí reparto. Cada agente arranca con su plan, no con una instrucción suelta.

El detalle que hace toda la diferencia es cuántos casos entran. **La cantidad la decide el riesgo, no lo que el agente es capaz de generar.** Un agente puede producir 40 casos para algo que necesita 6, y lo va a hacer encantado si se lo dejás. Esos 34 de más no son cobertura: son suite que hay que correr, mantener y leer en cada release.

Cuando generar es barato, la tentación es generar todo. Y ahí es donde el diseño de pruebas de siempre —el de los libros viejos, el que a veces suena a materia de facultad— vuelve a importar, por una razón nueva: ya no sirve para aprovechar el poco tiempo que tenías. Sirve para no ahogarte en el mucho que ahora te sobra.

---

## El problema que eso crea

Un agente escribe un test mirando la app que ya funciona. Abre la pantalla, ve que el total dice $14.380,77, y pone $14.380,77 como esperado. El test pasa a la primera y se ve impecable.

Si ese día la app estaba mal, el test pasa a defender el defecto.

A 10 tests por día yo leía los 10\. A 150 no leo ninguno completo. Y acá está el punto del post:

El andamiaje de control —el contrato de esperados, el auditor, los gates, la prueba de mutación— no es paranoia. Es **costo fijo**. Se paga una vez y se reparte sobre todos los tests que vengan después.

Con 8 tests por día ese aparato sería ridículo: tardaría más en montarlo que en leer los 8 tests a mano. A 150 por día es lo único que me separa de una suite grande y verde que no validó nada.

Dicho de otra forma: el volumen que la IA habilita es exactamente lo que vuelve obligatorio el control que a ese volumen se puede pagar.

---

## Recuperar el device dejó de ser algo que hago yo

Una corrida se me murió a la mitad: el emulador Android dejó de responder a los 55 minutos y de ahí en adelante cada spec tardaba dos minutos en fallar. Trece specs, dieciséis minutos perdidos.

\_Error: trataba la salud del device como un problema del momento. Si se colgaba lo reiniciaba a mano y seguía.

Eso funcionaba cuando el device era mío y yo estaba mirando. Hoy lo comparten siete agentes y yo no estoy adelante: un device colgado ya no me frena a mí, frena la cola. Y los mismos dos minutos por spec, pero sobre ciento cincuenta, son casi cuatro horas tiradas.

\_Aprendizaje: una falla de entorno no escala igual que el trabajo. Escala peor. Recuperar el device tuvo que dejar de ser algo que hago yo y pasar a ser parte de la corrida.

Ahora, antes de cada spec, hay un chequeo de diez segundos: si no responde se reinicia, si sigue colgado se relanza en frío, y si nada alcanza se aborta, así los specs que quedan fallan en un segundo en vez de dos minutos.

Nada de eso lo habría construido cuando escribía diez tests por día. No daba el número.

---

## Lo demás que automaticé por la misma razón

Con el device resuelto apareció lo que venía atrás. Cada cosa de esta lista me costó una corrida, una mañana o una pregunta repetida antes de que la automatizara.

| Qué                               | Cómo                                                                                                                                                            | Qué me ahorra                                                       |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| Varios agentes a la vez           | un worktree y una rama por agente, levantados por un script al empezar la jornada                                                                               | esperar a que uno termine para empezar otra tarjeta                 |
| Pocos devices para muchos agentes | un lock por device; el agente pide "el primero libre" y, si no hay, avisa y para                                                                                | coordinar a mano quién usa cuál                                     |
| Arranque de la jornada            | un script revisa que la rama de integración esté al día, que no queden slots sucios y que las carpetas compartidas sigan enganchadas                            | descubrir a mitad de una corrida que un agente arrancó sin contexto |
| Saber quién me necesita           | un aviso del sistema operativo cuando un agente termina o pide permiso                                                                                          | recorrer ventanas para ver quién está esperando                     |
| Datos antes de correr             | scripts que revisan el estado de los datos antes de empezar                                                                                                     | enterarme a los 40 minutos de que faltaba un dato                   |
| Que los tests puedan fallar       | cuando el agente termina y corre lo que hizo, corre una segunda vez con los esperados desplazados a propósito; si alguno sigue verde, esa aserción no mide nada | descubrir meses después que un test nunca se pudo poner rojo        |

Esa última fila la cuento entera en:

[Un verde que no validó nadaLas tres formas de fabricar un falso negativo en una suite, y cómo los medí: 50 aserciones mutadas, 0 sobrevivientes. Con prueba de mutación.![](https://cesarbeassuarez.dev/content/images/icon/android-chrome-192x192-5ae92997-241a-4899-b964-026d19f8d0df.png)cesarbeassuarez.devCésar Beas Suárez![](https://cesarbeassuarez.dev/content/images/thumbnail/feature-un-verde-que-no-valido-nada-1-9dfb2222-1e07-4b54-a74e-772ee72bfc0d.png)](https://cesarbeassuarez.dev/un-verde-que-no-valido-nada/)

Acá lo que importa es dónde quedó enganchada: no es algo que yo corro cuando me acuerdo, es un paso más del trabajo de cada agente antes de darme nada por terminado.

El diseño del plan es lo único que no delego. Eso, y los comandos de git: el agente me los da paso a paso y los corro yo. El lock de los devices es un seguro, no la última palabra — si estoy mirando el emulador Android y digo que se corra, se corre.

---

## Dos precisiones, antes de que las haga otro

La comparación no es limpia, y conviene decirlo yo.

**8 a 10 por día era una cuota que me ponían. 75 me lo pongo yo.** No es el mismo contrato. Si alguien me hubiera pedido 30 en aquel momento, tal vez habría llegado a 20 sin IA.

**Un test de hoy no es el mismo trabajo que uno de antes.** Hoy un caso nuevo cambia datos, no código: reusa los page objects y los flows que ya existen. Escribir el primer test contra una pantalla nueva sigue costando lo que costaba. Lo que se abarató es el caso número 40 de esa misma pantalla.

Así que el número real no es "15 veces más rápido". Es: la parte repetitiva se volvió casi gratis, y la parte que necesita criterio sigue costando lo mismo.

Que es exactamente lo que uno querría que pase.

---

## Dónde se me mudó el problema

Acá está la parte que no cierra todavía.

Ya no me cuesta escribir tests. Me cuesta **leer los rojos**.

De la última corrida completa quedaron 79 resultados sin clasificar. Cada uno hay que mirarlo y decidir qué es: un flaky que se recuperó, un defecto que ya tiene tarjeta, o un rojo nuevo que hay que reportar. Eso no lo puede hacer un agente, porque es justamente la parte que necesita criterio.

Genero más rápido de lo que clasifico. Y la brecha se abre sola: cuantos más tests tengo, más rojos produce cada corrida, y el tiempo que tengo para leerlos es el mismo.

No tengo resuelto esto. Lo que sí sé es que la respuesta no es generar menos, ni poner a un agente a cerrar rojos por su cuenta: sin verdes confiables, un agente iterando sobre rojos avanza hacia el falso verde, que es el problema del post [Un verde que no validó nada](https://cesarbeassuarez.dev/un-verde-que-no-valido-nada/).

---

## Lo que aprendí

Durante cuatro años, "ser más productivo" en automation significó escribir tests más rápido. Hoy escribir es la parte barata.

Lo caro es todo lo demás: decidir qué merece un test, saber que ese test puede fallar, y leer lo que la corrida devuelve. Las tres puntas del trabajo —el plan, el control y la lectura— son las que no se aceleraron, y son las únicas que no puedo delegar.

El trabajo no desapareció. Se corrió de lugar.