SDD vs TDD vs BDD vs DDD: diferencias y cuándo usar cada uno al programar con agentes de IA
SDD (*Spec-Driven Development*), TDD (*Test-Driven Development*), BDD (*Behavior-Driven Development*) y DDD (*Domain-Driven Design*) se suelen comparar como si fueran cuatro opciones entre las que elegir. No lo son: cada una responde a una pregunta distinta y trabaja a una altura diferente del proyecto. DDD decide con qué palabras modelas el negocio, BDD describe cómo se comporta el sistema para el usuario, SDD fija qué se escribe antes de que el agente programe y TDD comprueba que cada trozo de código funciona.
En este artículo explicamos qué es cada una, de dónde sale, una tabla de diferencias, cómo se ve la misma feature con cada enfoque y cómo aplicarlas en Claude Code, Codex o Cursor. Al final incluimos ODD (*Organic Driven Development*), la alternativa a SDD que más se está buscando, porque cierra el mapa.
Resumen rápido: qué es cada una
| Sigla | Nombre | Origen | Pregunta que responde | Qué produce |
|---|---|---|---|---|
| **DDD** | Domain-Driven Design | Eric Evans, libro de 2003 | ¿Qué modelamos y con qué palabras? | Lenguaje ubicuo, contextos delimitados, entidades y agregados |
| **BDD** | Behavior-Driven Development | Dan North, 2006 | ¿Cómo debe comportarse para el usuario? | Escenarios *Dado / Cuando / Entonces* (Gherkin) |
| **SDD** | Spec-Driven Development | Popularizado en 2025 por GitHub Spec Kit, Kiro y OpenSpec | ¿Qué se escribe antes de que el agente programe? | Especificación, plan técnico y lista de tareas |
| **ODD** | Organic Driven Development | Gentle-AI, flujo único desde la v4.0.0 (octubre de 2026) | ¿Cuánto plan necesita esta tarea concreta? | Nada, una tarea en línea o un único documento de feature |
| **TDD** | Test-Driven Development | Kent Beck, libro de 2002 | ¿Funciona este trozo de código? | Tests automáticos escritos antes que el código |
La clave para no confundirlas: DDD es diseño, BDD y TDD son formas de verificar (una desde fuera, otra desde dentro) y SDD y ODD son procesos para decidir cuánto se documenta antes de que el agente toque el código.
Qué es TDD (Test-Driven Development)
TDD es la práctica de escribir primero un test que falla y solo después el código mínimo que lo hace pasar. Kent Beck la formalizó en *Test-Driven Development: By Example* (2002), dentro de la corriente de Extreme Programming. El ciclo tiene tres pasos:
- Rojo: escribes un test para un comportamiento que aún no existe. Falla.
- Verde: escribes el código mínimo para que pase.
- Refactor: limpias el código sin romper el test.
Con agentes de IA, TDD gana importancia: es la forma más barata de comprobar que el agente hizo lo que pediste y no solo algo que *parece* correcto. Un test rojo antes del cambio y verde después es una evidencia; un "listo, ya está implementado" del agente no lo es.
Qué es BDD (Behavior-Driven Development)
BDD nace de TDD. Dan North lo presentó en 2006 ("Introducing BDD") porque los equipos se atascaban con preguntas como "¿qué testeo?" o "¿cómo llamo a este test?". Su respuesta: describir comportamientos en lenguaje del negocio, con una plantilla fija:
Escenario: no se puede reservar una franja ocupada
Dado que la franja de las 10:00 del martes ya está reservada
Cuando un cliente intenta reservar el martes a las 10:00
Entonces ve el mensaje "Esa hora ya no está disponible"
Y la reserva no se creaEse formato (Gherkin) lo ejecutan herramientas como Cucumber, pero lo importante no es la herramienta: es que cliente, desarrollador y agente leen el mismo criterio de aceptación. Si alguna vez has escrito "criterios de aceptación" en un ticket, ya has hecho BDD ligero.
Qué es DDD (Domain-Driven Design)
DDD es un enfoque de diseño de software, no de pruebas ni de proceso. Eric Evans lo describió en *Domain-Driven Design: Tackling Complexity in the Heart of Software* (2003). Tiene dos partes:
- DDD estratégico: un lenguaje ubicuo (las mismas palabras en el negocio, el código y la base de datos) y contextos delimitados (en "Reservas", *cliente* significa una cosa; en "Facturación", otra).
- DDD táctico: piezas de código como entidades, objetos de valor, agregados, repositorios y eventos de dominio.
Con un agente, la parte que más rinde es la estratégica: si el agente no conoce tu vocabulario, inventa nombres (Booking, Appointment, Reservation) para la misma cosa en tres archivos distintos. Un glosario en el repositorio lo evita. Lo contamos con un ejemplo en el artículo de grill-with-docs y domain-modeling.
¿DDD vs SDD? No compiten
La comparación "DDD vs SDD" aparece mucho en Google, pero mezcla dos cosas distintas. DDD decide cómo se organiza el modelo del negocio; SDD decide qué documentos se escriben antes de implementar. Puedes (y suele convenir) hacer las dos: la especificación de SDD usa el lenguaje ubicuo de DDD, y el plan técnico de SDD dice en qué contexto o módulo vive cada cambio.
Una nota sobre siglas: en este contexto DDD es casi siempre *Domain-Driven Design*. Existen otros usos (*Documentation-Driven* o *Data-Driven Development*), pero son mucho menos comunes.
Qué es SDD (Spec-Driven Development)
SDD pone una especificación escrita en el centro del trabajo con un agente: antes de pedir código, se escribe qué se construye, por qué y con qué criterios de aceptación. Del spec se deriva un plan técnico, una lista de tareas y, por último, la implementación. Las herramientas más conocidas son GitHub Spec Kit (MIT), Kiro de AWS y OpenSpec (MIT). Lo explicamos a fondo, con un spec.md de ejemplo, en qué es Spec-Driven Development.
Lo interesante para esta comparación es que SDD ya incluye BDD y TDD por dentro. Lo hemos comprobado en las plantillas de Spec Kit (rama principal, versión 1.4.2 en desarrollo, noviembre de 2026):
templates/spec-template.mdescribe los escenarios de aceptación con el formato de BDD:**Given** [initial state], **When** [action], **Then** [expected outcome].templates/constitution-template.mdpropone como principio de ejemplo "Test-First (NON-NEGOTIABLE)" con el ciclo rojo-verde-refactor de TDD.
Kiro hace algo parecido con otra notación: escribe los requisitos en EARS ("WHEN [evento] THE SYSTEM SHALL [comportamiento]"), que cumple el mismo papel que los escenarios de BDD.
Así que "SDD vs TDD" es una falsa elección: SDD es el proceso que decide qué tests hay que escribir, y TDD es la forma de escribirlos y pasarlos.
Y ODD: cuánto SDD necesita cada tarea
El problema de SDD aplicado a todo es la desproporción: un bug de tres líneas acaba convertido en varios Markdown que nadie revisa. ODD (*Organic Driven Development*), el flujo de Gentle-AI (MIT), propone que el agente decida en cada petición cuánta estructura hace falta: nada para una pregunta, una tarea en línea con test primero para un cambio pequeño, y un único documento con *Specs*, *Tasks* y *Log* para el trabajo grande.
ODD no sustituye a TDD ni a DDD: aplica test primero por defecto cuando hay un test útil y respeta el vocabulario del proyecto. Lo que sustituye es la parte de SDD que obliga a documentarlo todo. Lo explicamos a fondo, con fuentes y mediciones, en ODD vs SDD: qué es Organic Driven Development.
Tabla de diferencias
| DDD | BDD | SDD | ODD | TDD | |
|---|---|---|---|---|---|
| Tipo | Diseño | Verificación (fuera) | Proceso | Proceso | Verificación (dentro) |
| Quién lo lee | Negocio y equipo | Negocio, QA y equipo | Equipo y agente | Agente y tú | Equipo y agente |
| Cuándo se hace | Al empezar y al cambiar el modelo | Al definir cada feature | Antes de cada feature | En cada petición | Durante cada tarea |
| Artefacto típico | Glosario, mapa de contextos | `.feature` o criterios de aceptación | `spec.md`, `plan.md`, `tasks.md` | `odd/tasks/<feature>.md` solo si es grande | Archivos de test |
| Coste si se abusa | Diez carpetas para un formulario | Escenarios para cosas triviales | Expedientes para bugs pequeños | Poco plan en algo que sí lo necesitaba | Tests frágiles que nadie mantiene |
| Encaje con un agente | Glosario en el repo | Criterios en el ticket | Spec Kit, Kiro, OpenSpec | Gentle-AI o un bloque en `CLAUDE.md` | Skill de TDD o instrucción fija |
La misma feature con cada enfoque
Para verlo en concreto, tomemos una feature pequeña de una app de turnos para una peluquería: "un cliente no puede reservar una franja ya ocupada".
Con DDD, primero fijas las palabras. Una entrada en el glosario del repositorio:
**Franja**: intervalo de 30 minutos de un profesional en un día. Puede estar libre o reservada.
**Reserva**: una Franja asignada a un Cliente. Nunca se dice "cita" ni "turno" en el código.Con BDD, describes el comportamiento visible: el escenario Gherkin de la sección anterior.
Con SDD (Spec Kit), el agente genera un spec.md con historias de usuario y ese mismo escenario como criterio de aceptación, después un plan.md (qué tabla y qué endpoint cambian) y un tasks.md. Para una regla así son varios archivos.
Con ODD, el agente clasifica la tarea como pequeña (se entiende, el riesgo está acotado y se podría retomar con git diff), así que no crea documentos: va directo al test.
Con TDD, el test que falla antes del cambio:
import { describe, it, expect } from "vitest";
import { reservar } from "./reservas";
describe("reservar", () => {
it("rechaza una franja ya reservada", async () => {
await reservar({ franjaId: "mar-1000", clienteId: "c1" });
await expect(reservar({ franjaId: "mar-1000", clienteId: "c2" }))
.rejects.toThrow("Esa hora ya no está disponible");
});
});Fíjate en que los cinco enfoques conviven en la misma feature: el glosario da los nombres (franja, reservar), BDD da el mensaje exacto, SDD u ODD deciden cuánto papel se escribe y TDD lo demuestra.
Cómo aplicarlas en Claude Code
No necesitas instalar cinco herramientas. Esta es la combinación que recomendamos para una persona o un equipo pequeño:
- DDD ligero, una vez: un
GLOSSARY.mdcon 10-20 términos del negocio y una línea enCLAUDE.mdque diga "usa solo los términos del glosario". La skill grill-with-docs lo construye contigo a base de preguntas. - SDD ligero al empezar el proyecto: un PRD, una arquitectura y los tickets. Las skills to-spec y to-tickets convierten una conversación en eso. Spec Kit solo si la especificación es un entregable (cliente, equipo grande, sector regulado).
- BDD en cada ticket: criterios de aceptación en formato *Dado / Cuando / Entonces*, con los mensajes literales.
- ODD en el día a día: que el agente decida cuánto plan hace falta. Basta con el bloque de
CLAUDE.mdque publicamos en el artículo de ODD vs SDD. - TDD al implementar: test que falla primero. La skill tdd de Matt Pocock o el plugin Superpowers lo imponen.
Un bloque mínimo para CLAUDE.md que junta las cinco ideas:
## Cómo trabajar
- Vocabulario: usa solo los términos de GLOSSARY.md. Si falta uno, pregunta antes de inventarlo.
- Cada ticket trae criterios Dado / Cuando / Entonces. Copia los mensajes literales en los tests.
- Tarea pequeña: hazla en línea. Tarea grande (varias sesiones): crea docs/tareas/<feature>.md con Specs, Tasks y Log antes del primer cambio.
- Test primero: escribe el test, comprueba que falla, implementa y comprueba que pasa.
- No marques nada como hecho sin una prueba ejecutada.Errores frecuentes
- Elegir "una" metodología. Preguntar si usar SDD o TDD es como preguntar si usar un plano o una cinta métrica. Se usan juntas.
- Aplicar DDD táctico a un CRUD. Agregados, repositorios y eventos de dominio para un formulario de contacto añaden carpetas sin beneficio. Empieza por el glosario.
- Escenarios BDD sin mensajes literales. "Entonces ve un error" no se puede testear; "Entonces ve el mensaje 'Esa hora ya no está disponible'" sí.
- SDD completo para cada bug. Si el agente genera tres Markdown para cambiar una condición, estás pagando el coste de SDD sin su beneficio. Ahí encaja ODD.
- Tests escritos después por el agente. Un test que el agente escribe tras implementar suele comprobar lo que hizo, no lo que pediste. El orden importa: primero rojo.
Preguntas frecuentes
¿Cuál es la diferencia entre SDD y TDD?
SDD es un proceso: escribes una especificación, un plan y unas tareas antes de programar. TDD es una práctica de código: escribes un test que falla antes de cada cambio. Spec Kit, la herramienta de SDD más usada, incluye TDD como principio de ejemplo en su constitución.
¿DDD y SDD son lo mismo?
No. DDD (*Domain-Driven Design*) es diseño del modelo del negocio y su vocabulario; SDD (*Spec-Driven Development*) es el proceso de especificar antes de implementar. Se complementan: la especificación debería usar el lenguaje del dominio.
¿Qué diferencia hay entre BDD y TDD?
BDD describe el comportamiento visible para el usuario en lenguaje de negocio (*Dado / Cuando / Entonces*); TDD prueba unidades de código desde dentro. BDD nació como una forma de hacer TDD centrada en comportamientos.
¿Es SDD o SSD?
Es SDD, de *Spec-Driven Development*. SSD (*Solid State Drive*) es un tipo de disco y no tiene relación; es una errata muy común al buscar "odd vs sdd".
¿Qué es mejor para programar con IA: SDD u ODD?
Depende del tamaño. Para proyectos nuevos, contratos con clientes o equipos grandes, SDD. Para el trabajo diario sobre un proyecto existente, ODD, que solo escribe plan cuando la tarea lo necesita. Lo comparamos en detalle en ODD vs SDD.
Conclusión
SDD, TDD, BDD y DDD no son rivales: DDD da las palabras, BDD los criterios, SDD (u ODD, si quieres que el plan crezca con la tarea) decide cuánto se escribe antes de programar y TDD demuestra que funciona. Con un agente de IA, la combinación más práctica es un glosario, criterios *Dado / Cuando / Entonces* en cada ticket, plan solo para lo grande y test primero siempre.
El flujo completo, paso a paso
Si quieres montar todo esto en un proyecto real sin improvisar, la guía Claude Code de cero a producción lo recorre de principio a fin: planificar con SDD ligero y ODD (capítulo 4), trabajar por tickets con criterios de aceptación, elegir arquitectura con DDD táctico cuando conviene (capítulo 7), revisar el código con IA antes de subirlo (capítulo 10) y desplegar en Vercel o en tu propio VPS. Incluye 68 prompts, plantillas y skills listas para copiar, con un proyecto completo de ejemplo. Cuesta 19,99 USD, pago único: consigue la guía aquí.
Fuentes: Kent Beck, *Test-Driven Development: By Example* (2002) · Dan North, "Introducing BDD" (2006) · Eric Evans, *Domain-Driven Design* (2003) · GitHub Spec Kit (templates/spec-template.md y templates/constitution-template.md) · Kiro: conceptos de specs · Gentle-AI.
// código fuente
Nos ayuda a crecer
codigoagente es gratis y sin muros de pago. Si este artículo te sirvió, cualquiera de estas cosas mantiene el blog en marcha.
- Compártelo con alguien a quien le sirvaWhatsAppLinkedInXFacebook
- Llévate el kit para agenciasVer qué incluyeComprar
- Conoce a nuestro patrocinadorSafe Build Labs
Más sobre Agentes de IA

guía · Guía completa de ECC para Claude Code · #8
- Seguridad y revisión de código
- Claude Code

guía · Guía completa de ECC para Claude Code · #7
- Claude Code
- Skills para tus agentes

guía · Guía completa de ECC para Claude Code · #6
- Claude Code
- Skills para tus agentes