TDD con IA: guía a un agente con la kata Mars Rover
TDD con IA es guiar a un agente de código con tests: tú escribes cada test en rojo, el agente propone el código mínimo para pasarlo y tú revisas el diff antes del siguiente. Le pides a un agente de IA que resuelva una kata. En medio minuto te devuelve la solución completa y un puñado de tests, todos en verde. ¿Qué parte de eso has decidido tú? Si los tests se escribieron después del código, pasan porque describen lo que el código ya hace, no lo que tú querías. Este artículo desarrolla uno de los principios de la IA Limpia con un ejemplo completo: cómo guiar a un agente test a test, con TDD, para que cada línea que escribe responda a algo que has pedido.
Es el principio «Sin pruebas, no está terminado» llevado al día a día: primero se define qué debe pasar y después se pide el código. El ejemplo es la kata Mars Rover, en TypeScript y sin librerías de tests.
El código completo está en GitHub, en kata-mars-rover-tdd-con-ia, con un commit por cada fase del ciclo: puedes recorrer el historial y ver cada rojo, cada verde y cada refactor.
Si TDD te suena nuevo, empieza por qué es TDD y por el algoritmo de TDD. Aquí se dan por sabidos el ciclo rojo-verde-refactor y el uso básico de un agente de código.
El reparto: tú marcas, el agente pinta
Piensa en un pintor rapidísimo. Si le dices «pinta el salón», te pinta el salón, el pasillo y, de paso, el techo que querías dejar blanco. Si antes marcas con cinta la pared que toca, pinta esa pared, la miras y marcas la siguiente. Va igual de rápido, pero cada trozo es pequeño y lo revisas antes de seguir.
En TDD con un agente, el test en rojo es la cinta. Marca qué comportamiento toca ahora y deja fuera todo lo demás. El reparto de cada ciclo queda así:
| Fase | Quién | Qué se comprueba |
|---|---|---|
| Rojo | Tú escribes el test, o lo revisas si lo propone el agente | Que falla, y por la razón esperada |
| Verde | El agente propone el código mínimo | Que pasan todos los tests y que no se ha tocado ninguno |
| Refactor | Tú decides qué limpiar; el agente puede proponerlo | Que todo sigue en verde y que no cambia el comportamiento |
| Commit | Tú, al final de cada fase | Que el mensaje dice qué fase es |
El símil se queda corto en una cosa: la pintura se ve, y el código de más no. Un agente puede escribir una función entera que ningún test usa, y los tests seguirán en verde. Por eso el verde no basta: hay que mirar el diff buscando lo que no se ha pedido.
No es una idea nueva. Kent Beck publicó en junio de 2025 Augmented Coding: Beyond the Vibes, donde cuenta cómo programa con un agente siguiendo TDD a partir de una lista de tests en un fichero plan.md. En el apéndice, sus instrucciones al agente piden «implement only enough code to make that test pass», es decir, solo el código necesario para que pase ese test. En sus instrucciones, el agente escribe también el test a partir de esa lista; el reparto de este artículo deja el test en manos de la persona, que es una variante nuestra. Y entre las señales de que el agente se desvía, Beck apunta «Functionality I hadn’t asked for (even if it was a reasonable next step)»: funcionalidad que no había pedido, aunque fuera un siguiente paso razonable. Ese es justo el riesgo del ejemplo de más abajo. Otra de sus señales explica una regla de la petición que verás después: «Any indication that the genie was cheating, for example by disabling or deleting tests», cualquier indicio de que el genio hace trampas, por ejemplo desactivando o borrando tests.
La kata Mars Rover
Un rover está en un planeta dividido en casillas. Sabe en qué casilla está, (x, y), y hacia dónde mira: norte, este, sur u oeste (N, E, S, W). Desde la Tierra le llega una lista de comandos:
fyb: avanzar o retroceder una casilla (del inglés forward y backward).lyr: girar a la izquierda o a la derecha, sin moverse (left y right).
Hay dos requisitos más que llegan después. El planeta es redondo, así que el rover que sale por un borde aparece por el contrario. Y puede haber obstáculos: si el siguiente movimiento choca con uno, el rover se queda en la última casilla libre, deja de ejecutar comandos e informa del obstáculo.
Es el enunciado de Kata-Log, resumido. Kata-Log pide resolverla requisito a requisito, sin leer el siguiente hasta terminar el anterior, y por eso encaja bien con un agente: cada requisito nuevo pone a prueba si el código anterior era el mínimo o se había adelantado.
Sobre su origen, no se ha encontrado una fuente que lo documente. Kata-Log remite a un tutorial de Victor Farcic, fechado en 2014 según su dirección, que ya no está accesible en su dirección original, y a una versión más larga sin autor ni fecha en el archivo de Google Code, Mars Rover Technical Challenge, con otros comandos (L, R y M) y una meseta rectangular en lugar de un planeta.
El enunciado deja abiertas algunas decisiones, y aquí se toman así:
- El planeta del ejemplo mide 10 × 10 casillas, de
0a9en cada eje. - El norte suma uno a
yy el este suma uno ax. - El borde funciona como el tablero del Pac-Man: lo que sale por arriba entra por abajo. Kata-Log describe también un modelo más realista, con coordenadas polares, y avisa de que es más difícil.
Preparación: TypeScript sin compilar
El ejemplo usa TypeScript porque los tipos dejan escrita parte del contrato: qué comandos existen, qué devuelve el rover. Desde Node.js 23.6, Node ejecuta ficheros .ts directamente: quita los tipos y ejecuta el JavaScript que queda, sin comprobarlos. En Node 24 esa función es estable desde la versión 24.12.0, según su documentación. Así que los tests se lanzan igual que en JavaScript:
node --test
El ejecutor de tests de Node encuentra por sí mismo los ficheros *.test.ts. Para comprobar los tipos sí hace falta TypeScript, que se instala como única dependencia de desarrollo junto con los tipos de Node, las dos con versión fija:
npm install --save-dev --save-exact [email protected] @types/[email protected]
El tsconfig.json no genera ficheros y prohíbe la sintaxis que Node no sabe quitar, como los enum:
{
"compilerOptions": {
"target": "esnext",
"module": "nodenext",
"noEmit": true,
"strict": true,
"erasableSyntaxOnly": true,
"verbatimModuleSyntax": true,
"allowImportingTsExtensions": true,
"types": ["node"]
}
}
Con "check": "tsc" en los scripts de package.json, npm run check comprueba los tipos y npm test pasa los tests.
La petición al agente
Antes de empezar, el agente necesita saber las reglas del juego. Esta petición es un ejemplo construido, no la de una sesión real; adáptala a tu herramienta:
Vamos a hacer la kata Mars Rover con TDD, un test cada vez.
Yo escribo cada test en rojo. Haz solo el cambio mínimo para que pase, y para,
aunque parezca demasiado simple: los siguientes tests lo irán generalizando.
No modifiques ni borres tests. Si crees que un test está mal, para y dímelo.
Después de cada cambio, ejecuta npm test y npm run check, y enséñame el diff.
Ciclo 1: sin comandos, el rover no se mueve
El primer test es el más simple posible: si no llega ningún comando, el rover se queda donde estaba.
// rover.test.ts
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { ejecutar } from './rover.ts';
test('sin comandos, el rover se queda donde está', () => {
const rover = { x: 2, y: 3, direccion: 'N' } as const;
assert.deepEqual(ejecutar(rover, []), { x: 2, y: 3, direccion: 'N' });
});
Junto al test va la forma del código: los tipos y la firma de la función, con un cuerpo que aún no hace nada. Es la parte del diseño que conviene decidir a ti y no al agente, porque es lo que usará quien llame al rover.
// rover.ts
export type Direccion = 'N' | 'E' | 'S' | 'W';
export type Comando = 'f' | 'b' | 'l' | 'r';
export type Rover = { x: number; y: number; direccion: Direccion };
export function ejecutar(rover: Rover, comandos: readonly Comando[]): Rover {
throw new Error('Sin implementar');
}
node --test
✖ sin comandos, el rover se queda donde está
Error: Sin implementar
Falla por la razón esperada: la función existe, pero no hace nada. El verde del agente es una línea, return rover;. Primer commit del ciclo, (rojo); segundo, (verde).
Ciclo 2: avanzar hacia el norte, y el código que nadie pidió
Segundo test: con f, el rover que mira al norte avanza una casilla.
test('con f, el rover que mira al norte avanza una casilla', () => {
const rover = { x: 2, y: 3, direccion: 'N' } as const;
assert.deepEqual(ejecutar(rover, ['f']), { x: 2, y: 4, direccion: 'N' });
});
✖ con f, el rover que mira al norte avanza una casilla
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
{
direccion: 'N',
x: 2,
+ y: 3
- y: 4
}
Aquí llega la tentación. Lo que sigue es un ejemplo construido, no la respuesta de una sesión real: se ha escrito para mostrar un patrón, el de un agente que «se adelanta» y resuelve la kata entera de una vez.
export function ejecutar(rover: Rover, comandos: readonly Comando[]): Rover {
let { x, y, direccion } = rover;
for (const comando of comandos) {
if (comando === 'f' || comando === 'b') {
const paso = comando === 'f' ? 1 : -1;
if (direccion === 'N') y += paso;
if (direccion === 'S') y -= paso;
if (direccion === 'E') x += paso;
if (direccion === 'W') x -= paso;
} else {
const direcciones: Direccion[] = ['N', 'E', 'S', 'W'];
const giro = comando === 'r' ? 1 : -1;
direccion = direcciones[(direcciones.indexOf(direccion) + giro) % 4];
}
}
return { x, y, direccion };
}
Tiene buena pinta: avanza, retrocede, gira y está ordenado. Los dos tests pasan y tsc no se queja. Pero solo uno de esos tests mira el movimiento, y únicamente hacia el norte. El resto del código no lo comprueba nadie.
Hay una forma rápida de verlo: borra lo que creas que sobra y pasa los tests. Si se borran las líneas del sur, el este y el oeste, o el bloque entero de los giros, los dos tests siguen en verde. Ese código no lo ha pedido ningún test.
Y tiene un error. Al girar a la izquierda desde el norte, indexOf da 0, el giro resta uno y -1 % 4 en JavaScript es -1, no 3. La posición -1 de la lista no existe:
{ x: 2, y: 3, direccion: undefined }
Ningún test lo detecta, y los tipos tampoco: TypeScript da por hecho que leer una posición de la lista devuelve una Direccion. Con la opción noUncheckedIndexedAccess de tsconfig.json sí lo marcaría, porque esa lectura pasaría a ser Direccion | undefined; se ha comprobado con TypeScript 7.0.2. Los tipos ayudan, pero no sustituyen al test. Es el riesgo del código que nadie ha pedido: no está mal por ser de más, sino porque nadie lo ha comprobado.
La respuesta es rechazarlo y pedir el mínimo. Lo que entra en el commit es esto:
export function ejecutar(rover: Rover, comandos: readonly Comando[]): Rover {
if (comandos.length === 0) return rover;
return { ...rover, y: rover.y + 1 };
}
Parece poco, y es a propósito: los giros llegarán con sus propios tests, y uno de ellos es el que habría cazado el error. El agente no se ha equivocado por ser malo, sino por ser servicial: ha hecho el «siguiente paso razonable» del aviso de Beck.
Ciclo 3: un verde que parece trampa
Tercer test: con varios f, el rover avanza una casilla por cada uno.
test('con varios f, el rover avanza una casilla por cada uno', () => {
const rover = { x: 2, y: 3, direccion: 'N' } as const;
assert.deepEqual(ejecutar(rover, ['f', 'f', 'f']), { x: 2, y: 6, direccion: 'N' });
});
El rojo dice que el rover ha avanzado una casilla en lugar de tres. Y el mínimo que lo pasa es todavía más corto que el anterior:
export function ejecutar(rover: Rover, comandos: readonly Comando[]): Rover {
return { ...rover, y: rover.y + comandos.length };
}
Sumar el número de comandos es correcto mientras todos sean f y el rover mire al norte, que es justo lo que dicen los tests. Si al revisar te parece una trampa, tienes razón, y es útil: te dice cuál es el siguiente test que la desmonta.
Ciclos 4 a 8: direcciones, retroceso y giros
Los cinco ciclos siguientes repiten el mismo patrón. Cada test añade un comportamiento y cada verde es el mínimo para ese test:
| Ciclo | Test | Verde mínimo |
|---|---|---|
| 4 | Con f, avanza hacia donde mira: este, sur u oeste |
Una tabla AVANCE con el desplazamiento de cada dirección |
| 5 | Con b, retrocede una casilla sin girarse |
Contar los f y restar los b |
| 6 | Con r, gira a la derecha sin moverse, desde las cuatro direcciones |
Una tabla DERECHA: N → E, E → S… |
| 7 | Con l, gira a la izquierda sin moverse, desde las cuatro direcciones |
Una tabla IZQUIERDA |
| 8 | Sigue los comandos en orden: gira y luego avanza | Un bucle que aplica cada comando |
El test del ciclo 7 es el que habría pillado el error del ciclo 2:
test('con l, el rover gira a la izquierda sin moverse', () => {
assert.deepEqual(ejecutar({ x: 2, y: 3, direccion: 'N' }, ['l']), { x: 2, y: 3, direccion: 'W' });
assert.deepEqual(ejecutar({ x: 2, y: 3, direccion: 'W' }, ['l']), { x: 2, y: 3, direccion: 'S' });
assert.deepEqual(ejecutar({ x: 2, y: 3, direccion: 'S' }, ['l']), { x: 2, y: 3, direccion: 'E' });
assert.deepEqual(ejecutar({ x: 2, y: 3, direccion: 'E' }, ['l']), { x: 2, y: 3, direccion: 'N' });
});
Ejecutado contra la respuesta construida del ciclo 2, falla en la primera línea:
✖ con l, el rover gira a la izquierda sin moverse
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
{
+ direccion: undefined,
- direccion: 'W',
x: 2,
y: 3
}
Al terminar el ciclo 7, el código pasa los siete tests, pero se lee mal: cuenta comandos en lugar de seguirlos.
export function ejecutar(rover: Rover, comandos: readonly Comando[]): Rover {
const avance = AVANCE[rover.direccion];
const pasos = comandos.filter((c) => c === 'f').length - comandos.filter((c) => c === 'b').length;
return {
direccion: comandos.includes('r')
? DERECHA[rover.direccion]
: comandos.includes('l')
? IZQUIERDA[rover.direccion]
: rover.direccion,
x: rover.x + avance.x * pasos,
y: rover.y + avance.y * pasos,
};
}
No hace falta adivinar que esto se rompe con ['f', 'r', 'f', 'f']: el test del ciclo 8 lo dice, porque el rover acaba en (2, 6) en lugar de (4, 4). Su verde cambia las cuentas por un bucle que aplica los comandos uno a uno.
Refactor: cada comando, en su función
Con los ocho tests en verde, toca ordenar. Es un commit aparte, (refactor), que no cambia ningún comportamiento: separa qué hace cada comando.
export function ejecutar(rover: Rover, comandos: readonly Comando[]): Rover {
let actual = rover;
for (const comando of comandos) actual = aplicar(actual, comando);
return actual;
}
function aplicar(rover: Rover, comando: Comando): Rover {
switch (comando) {
case 'f':
return desplazar(rover, 1);
case 'b':
return desplazar(rover, -1);
case 'r':
return { ...rover, direccion: DERECHA[rover.direccion] };
case 'l':
return { ...rover, direccion: IZQUIERDA[rover.direccion] };
}
}
function desplazar(rover: Rover, sentido: 1 | -1): Rover {
const avance = AVANCE[rover.direccion];
return { ...rover, x: rover.x + avance.x * sentido, y: rover.y + avance.y * sentido };
}
El switch tiene una ventaja que da TypeScript: si mañana alguien añade un comando al tipo Comando y se olvida de tratarlo aquí, tsc avisa de que la función puede terminar sin devolver nada.
Separar el refactor del cambio de comportamiento también viene del texto de Beck. Sus instrucciones al agente piden «Never mix structural and behavioral changes in the same commit»: no mezclar en el mismo commit los cambios de estructura y los de comportamiento.
Antes del borde, un refactor preparatorio
El siguiente requisito es el borde del planeta, y el rover no sabe en qué planeta está. El test del borde necesita pasarle el planeta a ejecutar, pero ninguno de los ocho tests anteriores lo pasa.
Si se escribe el test nuevo tal cual, el verde obligaría a tocar los tests antiguos, que es justo lo que se le ha prohibido al agente. Así que, antes del rojo, va un refactor: la función recibe el planeta y todos los tests se lo pasan. Nada cambia de comportamiento y todo sigue en verde.
export type Planeta = { ancho: number; alto: number };
export function ejecutar(rover: Rover, comandos: readonly Comando[], planeta: Planeta): Rover {
const MARTE: Planeta = { ancho: 10, alto: 10 };
Las mismas instrucciones de Beck lo piden así: «Always make structural changes first when both are needed», primero los cambios de estructura cuando hacen falta los dos. Este paso es tuyo: cambia la interfaz pública y los tests, y esas decisiones no se delegan sin revisarlas.
Ciclo 9: el borde del planeta
test('al cruzar un borde, el rover aparece por el lado contrario', () => {
assert.deepEqual(ejecutar({ x: 4, y: 9, direccion: 'N' }, ['f'], MARTE), { x: 4, y: 0, direccion: 'N' });
assert.deepEqual(ejecutar({ x: 4, y: 0, direccion: 'S' }, ['f'], MARTE), { x: 4, y: 9, direccion: 'S' });
assert.deepEqual(ejecutar({ x: 9, y: 4, direccion: 'E' }, ['f'], MARTE), { x: 0, y: 4, direccion: 'E' });
assert.deepEqual(ejecutar({ x: 0, y: 4, direccion: 'E' }, ['b'], MARTE), { x: 9, y: 4, direccion: 'E' });
});
✖ al cruzar un borde, el rover aparece por el lado contrario
AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+ actual - expected
{
direccion: 'N',
x: 4,
+ y: 10
- y: 0
}
El verde añade una función pequeña que se usa al desplazarse. Fíjate en que suma la medida antes del resto, %: sin esa suma, una coordenada de -1 daría otra vez -1, el mismo tropiezo de la respuesta construida del ciclo 2.
// El planeta da la vuelta como el tablero del Pac-Man: lo que sale por un lado entra por el contrario.
function dentroDelPlaneta(coordenada: number, medida: number): number {
return (coordenada + medida) % medida;
}
Ciclo 10: los obstáculos
test('ante un obstáculo, el rover se para en la última casilla libre y lo informa', () => {
const conUnaRoca: Planeta = { ancho: 10, alto: 10, obstaculos: [{ x: 2, y: 5 }] };
const rover = { x: 2, y: 3, direccion: 'N' } as const;
assert.deepEqual(ejecutar(rover, ['f', 'f', 'f', 'r'], conUnaRoca), {
x: 2,
y: 4,
direccion: 'N',
obstaculo: { x: 2, y: 5 },
});
});
El test comprueba tres cosas a la vez: el rover se para en (2, 4), informa de la roca en (2, 5) y no ejecuta el resto de comandos, porque sigue mirando al norte aunque el último comando era r.
En este rojo, MARTE pasa a tener obstaculos: []. tsc se queja de que Planeta todavía no tiene ese campo, y está bien: el rojo puede no compilar. El verde añade el campo al tipo y la comprobación antes de cada movimiento. Con un último refactor, que usa Posicion también en la tabla AVANCE, este es el código final:
// rover.ts
export type Direccion = 'N' | 'E' | 'S' | 'W';
export type Comando = 'f' | 'b' | 'l' | 'r';
export type Posicion = { x: number; y: number };
export type Rover = Posicion & { direccion: Direccion };
export type Planeta = { ancho: number; alto: number; obstaculos: readonly Posicion[] };
export type Informe = Rover & { obstaculo?: Posicion };
const AVANCE: Record<Direccion, Posicion> = {
N: { x: 0, y: 1 },
E: { x: 1, y: 0 },
S: { x: 0, y: -1 },
W: { x: -1, y: 0 },
};
const DERECHA: Record<Direccion, Direccion> = { N: 'E', E: 'S', S: 'W', W: 'N' };
const IZQUIERDA: Record<Direccion, Direccion> = { N: 'W', W: 'S', S: 'E', E: 'N' };
export function ejecutar(rover: Rover, comandos: readonly Comando[], planeta: Planeta): Informe {
let actual = rover;
for (const comando of comandos) {
const siguiente = aplicar(actual, comando, planeta);
if (hayObstaculo(siguiente, planeta)) {
return { ...actual, obstaculo: { x: siguiente.x, y: siguiente.y } };
}
actual = siguiente;
}
return actual;
}
function aplicar(rover: Rover, comando: Comando, planeta: Planeta): Rover {
switch (comando) {
case 'f':
return desplazar(rover, 1, planeta);
case 'b':
return desplazar(rover, -1, planeta);
case 'r':
return { ...rover, direccion: DERECHA[rover.direccion] };
case 'l':
return { ...rover, direccion: IZQUIERDA[rover.direccion] };
}
}
function desplazar(rover: Rover, sentido: 1 | -1, planeta: Planeta): Rover {
const avance = AVANCE[rover.direccion];
return {
...rover,
x: dentroDelPlaneta(rover.x + avance.x * sentido, planeta.ancho),
y: dentroDelPlaneta(rover.y + avance.y * sentido, planeta.alto),
};
}
// El planeta da la vuelta como el tablero del Pac-Man: lo que sale por un lado entra por el contrario.
function dentroDelPlaneta(coordenada: number, medida: number): number {
return (coordenada + medida) % medida;
}
function hayObstaculo(posicion: Posicion, planeta: Planeta): boolean {
return planeta.obstaculos.some((obstaculo) => obstaculo.x === posicion.x && obstaculo.y === posicion.y);
}
Y los diez tests, que se leen como la especificación del rover:
node --test
✔ sin comandos, el rover se queda donde está
✔ con f, el rover que mira al norte avanza una casilla
✔ con varios f, el rover avanza una casilla por cada uno
✔ con f, el rover avanza hacia donde mira: este, sur u oeste
✔ con b, el rover retrocede una casilla sin girarse
✔ con r, el rover gira a la derecha sin moverse
✔ con l, el rover gira a la izquierda sin moverse
✔ el rover sigue los comandos en orden: gira y luego avanza
✔ al cruzar un borde, el rover aparece por el lado contrario
✔ ante un obstáculo, el rover se para en la última casilla libre y lo informa
ℹ tests 10
ℹ pass 10
ℹ fail 0
Cómo revisar cada verde del agente
El ejemplo deja una lista corta para cada vez que el agente propone un verde. La lista es interpretación nuestra a partir del ciclo de TDD, no una regla de Beck:
- ¿Ha tocado algún test? Mira primero el diff de los ficheros de test. Si ha cambiado un valor esperado o ha borrado un test, el verde no vale. Para que no dependa de que lo mires, se puede bloquear con un permiso o un hook que proteja los tests.
- ¿Cada línea nueva la pide un test? Borra la que dudes y pasa los tests. Si siguen en verde, esa línea sobra o le falta su test.
- ¿Pasan también los tipos?
npm testno comprueba los tipos, porque Node solo los quita. Pasanpm run checken cada verde. - Rompe el código a propósito de vez en cuando. En el código final, cambiar el
&&dehayObstaculopor||hace fallar el test del obstáculo; quitar la suma dedentroDelPlaneta, el del borde; y cambiar un giro deIZQUIERDA, el de girar a la izquierda. Si rompes algo y nada falla, falta un test. - Haz commit al final de cada fase. Si el siguiente intento del agente se complica, vuelves al último verde con
git stash --include-untracked, que aparta también los ficheros nuevos y se puede recuperar, y le pides algo más pequeño.
Un historial que se puede comprobar
En el repositorio, cada commit lleva en el mensaje su fase. Así empieza el historial:
git log --oneline --reverse
Inicia la kata con Node 24, TypeScript 7 para los tipos, node:test y licencia MIT
Sin comandos, el rover se queda donde está (rojo)
Sin comandos, el rover se queda donde está (verde)
Con f, el rover que mira al norte avanza una casilla (rojo)
Con f, el rover que mira al norte avanza una casilla (verde)
Con varios f, el rover avanza una casilla por cada uno (rojo)
La salida está recortada: se han quitado los identificadores de los commits y el resto de la lista, hasta 30 commits. El script scripts/comprobar-historial.sh los recorre todos y falla si un commit (rojo) pasa los tests, si uno (verde) o (refactor) no pasa los tests o la comprobación de tipos, o si un (verde) toca los tests. La integración continua lo ejecuta en cada push a main y en cada pull request. Es una forma de que el historial no sea solo un relato: si un commit dice que estaba en rojo, se puede comprobar.
Límites
- El agente también puede escribir los tests. Ahorra tiempo, pero entonces revisas tú cada test antes de verlo fallar, con más cuidado que el código. Un test mal planteado da por bueno un programa equivocado, y un agente que escribe el test y el código a la vez puede ajustar uno al otro.
- Los tipos no protegen lo que llega de fuera.
Comandoimpide escribir'x'en el código TypeScript, pero los comandos de verdad llegarían por la red, como texto. Validarlos sería un requisito nuevo, con sus tests. - Quedan preguntas sin test. ¿Qué pasa si el rover aterriza encima de un obstáculo? Hoy, al girar sin moverse, informaría de un obstáculo en su propia casilla. ¿Y un planeta de cero casillas? Ningún test lo decide, así que el código tampoco debería decidirlo por su cuenta. Son buenos siguientes tests.
- Es una kata, no un proyecto. Los pasos son pequeños porque el problema es pequeño. En un proyecto real, la lista de tests sale de hablar con quien conoce el negocio, y ningún agente la puede adivinar.
- Los ejemplos del agente son construidos. La petición y la respuesta que se excede se han escrito para este artículo. El código de esa respuesta está en la carpeta
ejemplos/del repositorio y se ha ejecutado contra los tests de su paso y contra el test de girar a la izquierda (npm run ejemplo). - Mars Rover es una kata muy conocida. Es probable que esté en los datos con los que se entrenan los modelos, y eso podría explicar que un agente se adelante con la solución entera; no hay forma de comprobarlo desde fuera. En tu propio código el agente no conoce la solución, pero puede seguir rellenando con lo que le parezca razonable.
- El script comprueba que cada rojo falla, no por qué. Un error de sintaxis también cuenta como rojo; mirar que el fallo es el esperado sigue siendo cosa tuya.
- Ir test a test es más lento que pedirlo todo de golpe, al menos al principio. No hay datos en este artículo que digan cuánto se gana después; lo que sí se gana es saber qué hace cada línea y por qué está ahí.
Tu siguiente paso
- Haz la kata primero sin agente. Después, repítela con él siguiendo el reparto de este artículo y compara los dos historiales.
- Escribe el test que falta: un rover que aterriza sobre un obstáculo. Decide tú qué debe pasar antes de pedirle el verde al agente. Si son varios criterios, escríbelos antes como especificación, como en el spec-driven development.
- Si dudas de por qué test empezar, ordena la lista con ZOMBIES: cero, uno, muchos. Y si el código ya existe y no tiene tests, el camino es otro: caracterízalo antes de que el agente lo toque.
- Para revisar diffs más grandes que los de una kata, sigue cómo revisar código generado por IA, y para elegir otra kata con la que practicar, la lista de katas por niveles; la siguiente puede ser el Juego de la Vida de Conway.
- Clona el repositorio del ejemplo y recorre su historial con
git log --reverse: cada commit es una fase del ciclo, ynpm run test:historialcomprueba que cada una hace lo que dice. Por eso este historial no se aplasta con un squash: cada commit es la prueba de una fase.
El contenido sobre IA envejece rápido. Última revisión: 15 de noviembre de 2026.
Fuentes
Consultadas el 10 y el 15 de noviembre de 2026:
- Kent Beck, «Augmented Coding: Beyond the Vibes», 25 de junio de 2025: el trabajo con un agente a partir de
plan.md, las señales de que el agente se desvía y la señal de que el agente hace trampas desactivando o borrando tests y las instrucciones del apéndice («implement only enough code to make that test pass», «Never mix structural and behavioral changes in the same commit» y «Always make structural changes first when both are needed»). Las traducciones son nuestras, y la lista de revisión de cada verde es interpretación nuestra. - Mars Rover Kata en Kata-Log: el enunciado, la regla de resolverla requisito a requisito y los dos modelos de borde. Kata-Log remite a un tutorial de Victor Farcic, fechado en 2014 según su dirección, que no se ha podido leer, porque su dirección original ya no lo sirve.
- Mars Rover Technical Challenge, archivo de Google Code: otra versión del enunciado, más larga, sin autor ni fecha.
- Documentación de Node.js 24: TypeScript (eliminación de tipos, estable desde la 24.12.0) y
node:test(los patrones de ficheros*.test.ts). - Versiones: Node.js 24.22.3, la de
.node-versiony la última de la rama 24, con el parche de seguridad del 10 de noviembre de 2026, y 26.13.1, la última estable y LTS activa según el índice de versiones de Node.js. TypeScript 7.0.2 y@types/node24.19.2, las últimas estables en npm (la segunda, la última para Node 24). - Código: todo el código se ha ejecutado el 10 de noviembre de 2026 con Node.js 24.21.0, commit a commit; el resultado final se ha vuelto a comprobar el 15 de noviembre de 2026 con las imágenes oficiales de Docker
node:24.22.3ynode:26.13.1, sin root, y el historial completo connpm run test:historial. Las salidas son las reales, recortadas a las líneas que importan y sin los tiempos de ejecución.