SDD vs vibe coding: la misma feature tres semanas después
SDD vs vibe coding con código real: la misma feature de cupones hecha dos veces. El refactor de la semana 3 rompe una regla y solo un test de spec lo frena.

La semana 1 el cupón funciona. La semana 2 también. La semana 3 le pides al agente "simplifica, hay código repetido" y te devuelve un diff limpio, más corto, más bonito. Lo apruebas.
Desde ese momento tu checkout regala un 10 % sobre productos que ya estaban rebajados. No hay error en consola. El build pasa. El único que se entera es el margen.
Esto es SDD vs vibe coding visto con código, no con opiniones. Es un caso ilustrativo: un ejemplo construido para este post, no un proyecto real ni un cliente. El código sí es real: cada fallo que vas a ver es salida literal de bun test.
En corto: en SDD vs vibe coding, lo que decide la semana 3 es dónde viven las reglas antiguas: en vibe coding, en un chat que nadie relee; en SDD, numeradas en una spec, cada una con un test que se pone rojo si alguien la rompe. En este caso el agente comete el mismo error en las dos pistas, pero solo en una llega a producción.
Que el vibe coding se tuerce hacia la tercera semana ya lo conté en del vibe coding al sistema. Aquí enseño el mecanismo, línea a línea.
¿Qué es SDD frente a vibe coding?
Spec-Driven Development (SDD) consiste en escribir primero las reglas de comportamiento, numeradas y verificables, derivar un test de cada una y solo después pedir el código; vibe coding consiste en pedir el código en conversación y aceptar lo que funciona en ese momento.
Las dos pistas reciben las mismas peticiones de negocio. La diferencia no es "IA sí o IA no". Es si la memoria del proyecto está en un archivo que se ejecuta o en tu cabeza.
La feature: cupones de un checkout con reglas que crecen
La feature es pequeña a propósito. Un módulo de descuentos en TypeScript, importes en céntimos, y tres peticiones de negocio:
- Semana 1: cupón
PERCENT10, un 10 % de descuento, pero nunca sobre productos rebajados. - Semana 2: cupón
MINUS5(5 € con compra mínima de 30 €) y envío gratis desde 50 €; si no, 4,99 €. - Semana 3: Black Friday. Se pueden combinar hasta dos cupones. Y "simplifica".
Pista A: vibe coding en tres conversaciones
La semana 1 es un prompt de una línea y un resultado correcto:
Añade un cupón PERCENT10: 10 % de descuento, pero no en productos rebajados.
export function applyCoupon(items: Item[], code?: string): number {
let total = 0;
for (const item of items) {
let line = item.price * item.qty;
if (code === 39;PERCENT1039; && !item.onSale) {
line = line * 0.9;
}
total += line;
}
return Math.round(total);
}
Fíjate dónde vive la regla de los rebajados: en un if dentro de un bucle. Y en el chat de ese día.
La semana 2 el agente no toca applyCoupon. Añade una función nueva al lado:
export function calculateTotal(items: Item[], code?: string) {
const subtotal = items.reduce((s, i) => s + i.price * i.qty, 0);
let discounted = applyCoupon(items, code);
if (code === 39;MINUS539; && subtotal >= 3000) discounted -= 500;
const shipping = subtotal >= 5000 ? 0 : 499;
return { subtotal, shipping, total: discounted + shipping };
}
Ya hay dos funciones públicas que calculan precios, y el subtotal se calcula en dos sitios. El envío gratis mira el subtotal antes del descuento. Nadie lo pidió así; simplemente salió así.
La semana 3 llega la petición que lo cambia todo:
Black Friday: deja combinar hasta dos cupones.
Y simplifica, hay lógica repetida entre applyCoupon y calculateTotal.
const COUPONS: Record<string, (total: number) => number> = {
PERCENT10: (t) => t * 0.9,
MINUS5: (t) => (t >= 3000 ? t - 500 : t),
};
export function calculateTotal(items: Item[], codes: string[] = []) {
const subtotal = items.reduce((s, i) => s + i.price * i.qty, 0);
let total = subtotal;
for (const code of codes.slice(0, 2)) {
total = COUPONS[code]?.(total) ?? total;
}
const shipping = total >= 5000 ? 0 : 499;
return { subtotal, shipping, total: Math.round(total) + shipping };
}
// Se mantiene por compatibilidad con el checkout
export const applyCoupon = (items: Item[], code?: string) =>
calculateTotal(items, code ? [code] : []).total;
Es mejor código en apariencia. Más corto, extensible, sin duplicación. Y está roto de tres maneras.
Lo que rompe el vibe coding en la semana 3 (y SDD no)
Para medirlo, estos son los tests que nadie escribió durante esas tres semanas, ejecutados a posteriori contra las tres versiones. Esta es la salida real de bun test vibe:
(fail) vibe semana 3 > PERCENT10 no descuenta productos rebajados
Expected: 5600
Received: 5400
(fail) vibe: el contrato de applyCoupon > semana 3: applyCoupon sin cupón devuelve el importe de productos
Expected: 2000
Received: 2499
(fail) vibe semana 3: problemas nuevos > el orden de los cupones no cambia el precio
Expected: 2929
Received: 3379
3 pass
3 fail
Regresión silenciosa de la semana 1. Un teclado de 40 € y un ratón rebajado de 20 €. La regla original cobra 56 €; la semana 3 cobra 54 €. El filtro !item.onSale no se borró por descuido: desapareció porque la nueva firma (total: number) => number recibe un número, no las líneas. Con esa forma, la regla ya no se puede ni escribir.
Un arreglo que rompe otra cosa. El envoltorio "por compatibilidad" de applyCoupon devuelve ahora el total con envío. Un carrito de 20 € sin cupón pasa de 20,00 a 24,99. Cualquier pantalla que mostraba "precio con descuento" muestra ahora otra cosa, con el mismo nombre de función.
El orden de los cupones cambia el precio. Un libro de 32 €. Con PERCENT10 y luego MINUS5, el total baja a 28,80 antes de evaluar el mínimo de 30 €, así que MINUS5 no aplica: 33,79 € con envío. En orden inverso: 29,29 €. Una diferencia de 4,50 € según qué cupón teclee primero el cliente.
Y un cuarto cambio que ningún test detecta: el envío gratis pasó de mirar el subtotal a mirar el total con descuento. Puede que sea lo correcto. Nadie lo decidió.
Pista B: en SDD la spec cambia antes que el código
En la pista SDD, cada petición de negocio entra primero en spec.md como reglas numeradas. Esto es lo que había al final de la semana 3:
Semana 1:
- R1. PERCENT10 descuenta el 10 % de la suma de líneas no rebajadas.
- R2. Las líneas con onSale: true nunca reciben descuento porcentual.
- R3. El descuento se redondea al céntimo una sola vez, al final.
- R4. Un código desconocido no rompe nada: va a `rejected`.
Semana 2:
- R5. MINUS5 descuenta 500 si el subtotal es >= 3000.
- R6. El total de productos nunca baja de 0.
- R7. Envío 499; gratis si el total de productos tras descuentos es >= 5000.
Semana 3:
- R8. Máximo 2 cupones distintos; el tercero va a `rejected`.
- R9. El orden no cambia el precio: primero porcentuales, luego fijos.
- R10. Los mínimos (R5) se evalúan sobre el subtotal antes de descuentos.
R7, R9 y R10 son exactamente las decisiones que la pista A nunca tomó. Escribir la spec te obliga a decidir antes de que el agente decida por ti. Después, un test por regla, con el id en el nombre:
test(39;R2 · las líneas rebajadas no reciben descuento porcentual39;, () => {
expect(priceCart([keyboard, saleMouse], [39;PERCENT1039;]).discount).toBe(400);
});
test(39;R9 · el orden de los cupones no cambia el precio39;, () => {
expect(priceCart([book], [39;PERCENT1039;, 39;MINUS539;]).total)
.toBe(priceCart([book], [39;MINUS539;, 39;PERCENT1039;]).total);
});
El prompt de la semana 3 ya no describe la feature. Señala el contrato:
Lee spec.md. He añadido R8, R9 y R10 y sus tests.
Implementa priceCart hasta que pase `bun test sdd`.
No cambies los tests ni las reglas R1-R7.
Ahora supón que, en la pista B, el agente también intenta simplificar con el mismo atajo, un mapa de funciones sobre el subtotal entero. Este es ese primer intento, escrito para el ejemplo:
const COUPONS: Record<string, (subtotal: number) => number> = {
PERCENT10: (subtotal) => subtotal * 0.1,
MINUS5: (subtotal) => (subtotal >= 3000 ? 500 : 0),
};
Salida real de IMPL=first-refactor bun test sdd:
(fail) priceCart [first-refactor] > R2 · las líneas rebajadas no reciben descuento porcentual
Expected: 400
Received: 600
9 pass
1 fail
Mismo error que en la pista A. La diferencia es que aquí un test escrito en la semana 1, con nombre propio, se pone rojo en la semana 3, antes del merge. La versión corregida pasa los cupones de nuevo por las líneas:
PERCENT10: {
kind: 39;percent39;,
// R1 + R2: solo líneas no rebajadas
discount: (items) =>
items.filter((i) => !i.onSale).reduce((s, i) => s + lineTotal(i), 0) * 0.1,
},
bun test sdd sobre la versión final: 10 pass, 0 fail.
Esta es la tesis del post: SDD no hace al agente más listo. Hace que su error sea visible. Y eso solo funciona si la spec es verificable, que es justo donde fallan casi todas; lo detallo en por qué tu spec falla con un agente. Si quieres el método completo, de la plantilla a la revisión, está en el libro de Spec-Driven Development.
SDD vs vibe coding semana a semana
| Vibe coding (pista A) | SDD (pista B) | |
|---|---|---|
| Semana 1 | 1 prompt, 1 función, funciona | R1-R4 + 4 tests, luego el código |
| Semana 2 | Segunda función pública; subtotal calculado en dos sitios; envío sin decidir | R5-R7; R7 decide que el envío mira el total con descuento |
| Semana 3 | El refactor rompe R2, cambia el contrato de applyCoupon y el orden altera el precio |
El primer refactor rompe R2, el test lo para, se corrige |
| Dónde viven las reglas | En el historial del chat | En spec.md y en el nombre de cada test |
| Tests al final | 0 durante el desarrollo; de los 6 escritos a posteriori, 3 fallan | 10 escritos antes del código; 10 pasan |
| Limitación o riesgo | Las regresiones llegan a producción sin ruido | Si la spec está mal, los tests verifican el error con total confianza |
Que esto además salga más barato en tokens es otra discusión, con números, en la factura del vibe coding.
Lo que se dice en Hacker News
En Hacker News, el 2 de noviembre de 2026, en el hilo "In LLM era, can software startup survive?", anandj82 avisaba de lo que le espera a quien construye sin saber de software: "In 2 months time, the non s/w engineer is gonna drown in keeping up with all the pieces of the product without regression."
Unos meses antes, en "Domain expertise has always been the real moat", locknitpicker describía a un compañero que "introduced a bunch of regressions that [sic] by mindlessly vibe-coding things against the requirements".
Fíjate en el final: against the requirements. Los requisitos existían. Lo que no existía era algo que los comprobase en cada cambio.
Cuándo NO usar SDD
Cuando el error solo lo pagas tú. Un prototipo que vas a tirar no necesita R1-R10. Lo desarrollo en cuándo sí usar vibe coding: la frontera no es el tamaño del proyecto, es quién paga el fallo.
Cuando todavía no sabes las reglas. Si estás explorando qué debe hacer la feature, una spec escrita ahora es una spec inventada. Haz el spike en modo vibe, tíralo y escribe la spec con lo aprendido.
Cuando la spec está mal. Los tests verifican que el código cumple lo que escribiste, no lo que el negocio quería. Si R2 es una mala regla, tienes una mala regla con diez tests en verde.
Cuando crees que diez ejemplos cubren la regla. R9 está probada con un solo carrito. Para reglas como "el orden no importa" encaja mejor property-based testing con fast-check, y para saber si tus tests detectan algo, mutation testing con Stryker.
Cómo aplicar SDD a tu feature con reglas esta semana
Elige el módulo de tu proyecto con más reglas de negocio: precios, permisos, estados de un pedido. Escribe sus reglas tal como funcionan hoy, numeradas, entre cinco y diez. Un test por regla, con el id en el nombre. Y que tu próximo prompt al agente empiece por "lee spec.md y no toques R1-Rn".
Tu agente va a cometer errores así, con spec o sin ella. Lo único que eliges es si te enteras por un test rojo o por el email de un cliente.
Si quieres practicarlo con un proyecto guiado, con AGENTS.md, contratos y revisión del código que genera el agente, eso es lo que hacemos en el workshop SDD + Agentic Engineering.
Preguntas frecuentes
¿SDD vs vibe coding: cuál es más rápido?
Vibe coding es más rápido la primera semana: un prompt, frente a una spec y cuatro tests antes de la primera línea de código. En este caso, la ventaja desaparece en la semana 3, cuando la pista A tiene tres fallos sin detectar y la pista B tiene uno detectado antes del merge.
¿Los tests de la spec los puede escribir el propio agente?
Sí, pero revísalos tú antes de pedir el código. Si el mismo agente escribe tests e implementación en el mismo paso, puede ajustar unos a otros. El orden importa: spec, tests revisados y después código.
¿Por qué numerar las reglas de la spec?
Porque el número viaja. Aparece en el test, en el comentario del código y en el prompt ("no toques R1-R7"). Cuando un test se pone rojo, R2 te dice qué decisión de negocio se rompió sin leer el diff.
¿Necesito una herramienta especial para hacer SDD?
No. En este caso basta un spec.md, un archivo de tests y bun test. Las herramientas ayudan a generar la estructura, pero lo que frena la regresión es que cada regla tenga un comando que la compruebe.
Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.
¿Quieres construir con agentes en serio?
Curso «Construye con IA» con Claude Code, de la idea al producto.
Developer con más de 15 años en frontend y creador de Dominicode. Escribe sobre IA aplicada al desarrollo de software.
¿Te resultó útil este artículo?
Compártelo con tu comunidad y ayuda a otros desarrolladores.