Tag: Spec Driven Development

  • Implementa Spec-First y TDD para asegurar código con Claude Code

    Implementa Spec-First y TDD para asegurar código con Claude Code

    Spec-First + TDD: el combo que hace que Claude Code no rompa nada

    Tiempo estimado de lectura: 4 min

    • Spec-First transforma requisitos en contratos ejecutables que eliminan ambigüedades.
    • TDD convierte esos contratos en tests que fallan primero (Red) y obligan a implementar hasta pasar (Green).
    • El flujo reduce suposiciones del agente, evita happy-paths y deuda técnica silenciosa.
    • Requiere versionar specs y tests junto a la implementación para trazabilidad y control.

    Spec-First + TDD: el combo que hace que Claude Code no rompa nada. Díselo a cualquier equipo que delega implementaciones críticas a un agente y observarás tres problemas: suposiciones, happy-paths y deuda técnica que aparece en silencio. Este patrón invierte el orden habitual: especificación primero, tests que fallan después, implementación solo para pasar tests. Resultado: la IA implementa contra contratos ejecutables, no contra intuiciones.

    Resumen rápido (lectores con prisa)

    Spec-First convierte requisitos en contratos ejecutables. TDD transforma esos contratos en tests rojos que deben pasar. El agente implementa únicamente para lograr que pnpm test devuelva exit code 0. Menos ambigüedad, más trazabilidad, menos regresiones.

    Spec-First + TDD: qué es y por qué lo necesitas con Claude Code

    Claude Code y otros agentes son excelentes generadores de código, pero su entrenamiento los empuja a soluciones “plausibles”, no necesariamente correctas para tu dominio. La solución no es prompts más largos; es cambiar el flujo de trabajo.

    Spec-First + TDD combina:

    • Spec-First: transformar requisitos en un contrato preciso y ejecutable (feature-spec.md).
    • TDD: traducir ese contrato a tests que inicialmente fallan (Red).
    • Implementación: conceder al agente la tarea de alcanzar el verde (Green) ejecutando y corrigiendo hasta que pnpm test devuelva exit code 0.

    Links útiles: Claude Code docs y Vitest para ejemplos de runners.

    Flujo operativo paso a paso

    1) Escribir la especificación (Spec)

    La especificación no es un texto largo: es un contrato. Define funciones, inputs, outputs, errores y reglas inmutables.

    Ejemplo (feature-spec.md):

    Feature: applyDiscount(order, coupon)
    
    Función: applyDiscount(order, coupon)
    Inputs:
    - order: { id, subtotal, userId, items[] }
    - coupon: { code, type: 'percentage'|'fixed', value, minOrder, expiresAt }
    
    Reglas:
    - Si coupon.expiresAt < now -> DiscountExpiredError
    - Si order.subtotal < coupon.minOrder -> OrderBelowMinimumError
    - total = max(0, subtotal - discount)
    

    Si necesitas respuesta HTTP o formatos JSON exactos, escríbelos. Nada queda implícito.

    2) Generar esqueletos de tests que fallen (Red)

    Pide a Claude que genere solo los tests: archivos Vitest/Jest que describan las aserciones exactas. Estos tests deben fallar inicialmente porque la implementación aún no existe.

    Ejemplo breve (applyDiscount.test.ts):

    import { applyDiscount } from './applyDiscount'
    import { DiscountExpiredError } from './errors'
    
    it('lanza DiscountExpiredError si el cupón expiró', () => {
      expect(() => applyDiscount(orderExpired, couponExpired)).toThrow(DiscountExpiredError)
    })
    

    Ejecuta pnpm test localmente o desde el agente. Verás rojo: eso es correcto. Tienes un contrato ejecutable.

    3) Implementación: el agente repara hasta verde

    Autoriza a Claude a escribir el código con una instrucción clara:

    “Implementa applyDiscount() conforme a feature-spec.md. Ejecuta pnpm test y corrige hasta que todos los tests pasen. No modifiques los tests.”

    El agente iterará: escribir, ejecutar, leer errores, corregir. Termina cuando el runner devuelve 0. Esa condición objetiva sustituye la “autovalidación” del modelo.

    Beneficios reales y medibles

    • Trazabilidad: cada cambio está ligado a un test derivado de una especificación humana.
    • Determinismo: el criterio de finalización es el estado del test runner, no el juicio subjetivo del agente.
    • Menos regresiones: CI bloqueará commits que rompan contratos; el agente ya trabaja para pasar esa barrera.
    • Refactor seguro: optimizar sin romper es posible porque la suite revisa invariantes.

    Métricas a monitorear: porcentaje de PRs que pasan en la primera ejecución de CI, número de reverts por errores de negocio, tiempo medio para retomar trabajo en sesiones de agente.

    Cuándo aplicar este combo (y cuándo no)

    Aplica Spec-First + TDD cuando:

    • La lógica tiene invariantes críticas: facturación, pagos, permisos.
    • La feature afecta múltiples consumidores del API.
    • Vas a delegar implementación a sesiones autónomas del agente.

    No lo uses para:

    • Prototipos visuales donde la iteración UX prima.
    • Scripts puntuales o migraciones one-off.
    • Cambios triviales donde crear tests cuesta más que la implementación.

    Buenas prácticas y guardrails

    • Versiona feature-spec.md junto con la PR que implementa la feature.
    • No permitas que el agente modifique tests sin revisión humana.
    • Mantén artefactos pequeños: especificaciones por feature, no documentos gigantes.
    • Incluye en CLAUDE.md la referencia a specs y al contrato de proyecto para que Claude cargue el contexto inicial: esto reduce fricción y errores de interpretación (ver docs).

    Spec-First + TDD no es un ritual: es control. Si quieres que Claude Code deje de ser creativo y empiece a ser fiable, escribe contratos ejecutables primero, exige tests rojos y permite que la IA solo implemente para pasar tests. El resultado no es menos velocidad: es menos correcciones, menos deuda y más confianza en el código que llega a producción.

    Dominicode Labs

    Para equipos que automatizan con agentes y workflows, un laboratorio de pruebas y plantillas de specs acelera la adopción. Consulta Dominicode Labs como continuación lógica para crear artefactos y plantillas reutilizables.

    FAQ

    Respuesta: Spec-First es un contrato ejecutable que define funciones, inputs, outputs y errores de forma precisa. La documentación normal puede ser descriptiva; la spec exige reglas inmutables y formatos exactos que pueden traducirse a tests automatizados.

    Respuesta: Forzar tests rojos crea un criterio objetivo: la implementación debe satisfacer el contrato verificable. Evita que el agente implemente “por intuición” y asegura que el código cumpla casos límites y errores definidos.

    Respuesta: Usa runners como Vitest o Jest para ejecutar tests. Ejecuta pnpm test en CI y localmente para validar que el agente alcanzó exit code 0.

    Respuesta: Políticas de revisión de PR que bloqueen merges si los tests cambian sin aprobación humana y reglas de CI que rechacen cambios en archivos de tests son medidas efectivas. Además, incluye en el proceso de aceptación la verificación de artefactos versionados.

    Respuesta: Hay una inversión inicial: escribir specs y tests. Esa sobrecarga se compensa con menos rework, menos regresiones y mayor velocidad a largo plazo cuando los agentes trabajan contra contratos claros.

    Respuesta: Métricas recomendadas: porcentaje de PRs que pasan en la primera ejecución de CI, número de reverts por errores de negocio y tiempo medio para retomar trabajo en sesiones de agente.

  • Cómo evitar problemas al pedir código a la IA sin especificaciones

    Cómo evitar problemas al pedir código a la IA sin especificaciones

    ¿Quieres velocidad o quieres un desastre bonito en producción?

    Tiempo estimado de lectura: 6 min

    • Ideas clave:
    • Pedir código antes de una spec convierte velocidad aparente en deuda técnica real.
    • La spec funciona como el “system prompt” del repositorio: contratos, reglas y criterios de aceptación evitan improvisaciones.
    • Procesos concretos —plan, contratos, red teaming, tests— transforman las respuestas rápidas de IA en soluciones sostenibles.
    • El rol senior evoluciona hacia guardián de límites y políticas, no solo autor de código.

    Poca gente dice esto en las charlas con café gratis: pedir código antes de dar contexto es como contratar a un pintor y no decirle qué pared. Va a pintar rápido. Va a quedar espectacular al principio. Y al primer olor a humo descubrirás que pintó sobre el sistema eléctrico.

    Resumen rápido (lectores con prisa)

    La IA genera código probables según datos y prompts. Sin una spec que defina objetivos, stack, contratos y criterios de aceptación, las soluciones serán rápidas pero frágiles. Escribe SPEC.md, publica contratos, exige plan y tests; audita con red teaming. Conserva disciplina para convertir velocidad en sostenibilidad.

    Poca gente habla de esto: la IA no entiende tu negocio

    Los modelos de lenguaje son máquinas de probabilidades. No entienden SLAs, ni GDPR, ni las peleas internas por usar Next.js o Svelte. Responden con lo más probable según su entrenamiento y tu prompt. Si no les das reglas, toman decisiones por ti. Decisiones elegantes, pero improvisadas. Y la improvisación no escala.

    Lo que pasa cuando pides código demasiado pronto

    No es teoría. Es patrón repetido en equipos que adoptan IA rápido y disciplina lenta:

    Demo brillante en 48 horas. Integración rota, tokens expuestos, tests que fallan en producción. Dos semanas de refactor para rescatar el proyecto.

    Síntomas concretos

    • Componentes gigantes que hacen todo: UI, llamadas HTTP, validaciones y cambios en la base de datos. Un archivo de 500 líneas que asusta.
    • Mezcla de librerías por impulso: Fetch aquí, Axios allá, una dependencia vieja que “funcionaba” en un tutorial.
    • Flujos automatizados (n8n, Zapier) que fallan ante el primer timeout porque nadie pensó en idempotencia.
    • Tests que existen pero no validan casos reales. O peor: pruebas que pasan porque la spec nunca fue clara.

    Alucinación arquitectónica: la versión elegante del desastre

    No es solo que la IA invente funciones. Inventará abstracciones. Te propondrá un patrón porque en sus datos aparece muchas veces. Puede recomendarte Event Sourcing para una app de encuestas. Te entregará un PR perfecto. Y tú, encantado, lo mergeas.

    Hasta que llega la primera incidencia. Hasta que un miembro nuevo del equipo abre ese PR y no entiende nada. La IA actúa con convicción. Por eso hace falta liderazgo humano que coloque límites.

    La spec: no es burocracia. Es supervivencia

    Quien sigue llamando a la spec “ese PDF que nadie lee” está mirando el problema con los ojos cerrados. En la era de la IA la spec es la única forma de que la creatividad de la herramienta aterrice donde debe.

    Piensa en la spec como el System Prompt del repositorio. No es un texto largo que nadie abre; es la brújula del proyecto. Contiene: objetivos, stack, reglas innegociables, modelos de datos, respuestas ante fallos, y criterios de aceptación.

    Si la IA fuera un barco y tu equipo fuera la tripulación, la spec es la brújula. Sin ella, el barco navega rápido y choca.

    Cómo evitar pedir código demasiado pronto (pasos concretos)

    No es magia. Es disciplina con sentido. Haz esto antes del primer commit generado por IA.

    1) Escribe el objetivo en una frase

    ¿Qué problema resuelve este módulo? ¿Qué NO debe hacer? Si no puedes decirlo en una frase, no lo pidas. La IA no lo adivina.

    2) Define el stack y las reglas innegociables

    Next.js 14 OK. No usar SSR en X páginas. No introducir nueva dependencia sin CVE-check. ¿Postgres o Mongo? ¿Monolito o microservicios? Quítale opciones a la IA para que deje de improvisar.

    3) Publica contratos antes que código

    Interfaces TypeScript, esquemas Prisma, OpenAPI. Si la IA tiene contratos, genera lógica que encaje. Si no los tiene, generará sutilezas que rompen todo.

    4) Exige plan antes de ejecución

    Pide un plan en pasos. Repite: plan. No “hazlo tú ahora”. Pide la lista de entregables, aprobala y luego ejecuta cada paso con prompts acotados.

    5) Red Teaming desde el minuto cero

    Pídele a la IA que sea adversaria: “Rompe este diseño.” “¿Qué falla con 10k req/s?” “¿Qué pasa si el proveedor OAuth cae 30s?” Esto saca a la luz cuellos de botella y casos límite.

    6) Testes y ejemplos junto al contrato

    Cada endpoint debe venir con payloads válidos e inválidos y tests de aceptación. Si la IA genera código sin tests que validen la spec, recházalo.

    7) Guarda la spec en el repo (no en Google Docs)

    SPEC.md, .cursorrules, spec.json. Ponlo en la raíz. Que sea lo primero que lea el agente cuando genere código.

    Plantilla mínima de SPEC.md (pégala ya)

    No la copies sin adaptar, pero ten algo así en la raíz del repo:

    • Título en una frase: Objetivo del módulo.
    • Stack aprobado: Next.js 14, Node 20, Postgres 15.
    • Reglas innegociables:
      • No exponer secretos en frontend.
      • Mutaciones por Server Actions.
      • Máximo 2 dependencias nuevas sin revisión de seguridad.
    • Contratos principales:
      • /api/users POST -> CreateUserRequest, CreateUserResponse (interfaces TypeScript)
      • DB: users (id uuid, email text unique, password_hash text)
    • Criterios de aceptación:
      • Test de integración que crea usuario y valida hash.
      • Tiempo máximo respuesta: 500ms en endpoint crítico.
    • Política de secretos: usar Vault, nunca env vars en texto plano.
    • Responsables: Tech Lead: @ana, Owner: @carlos.

    Prompts que funcionan (ejemplos directos)

    Un buen prompt = contexto + restricciones + output esperado.

    Malo: “Hazme un CRUD de users.”

    Bueno: “Te doy la spec (inserta SPEC.md). Genera: 1) Interfaces TS 2) OpenAPI para /api/users 3) Tests de integración con ejemplos válidos/ inválidos. No uses librerías externas para hashing. Tiempo de respuesta <500ms.”

    Divide el trabajo en sprints cortos y verificables

    • Sprint A: Modelo de datos + contratos + tests.
    • Sprint B: Endpoints críticos + seguridad.
    • Sprint C: Observabilidad y despliegue.

    Aprobar cada sprint antes de pasar al siguiente.

    El nuevo rol del Senior: faro y guardián, no solo coder

    Antes bastaba con saber la sintaxis. Hoy el valor está en definir límites, auditar reglas y decidir qué complejidad merece implementarse. El senior no codifica menos; decide mejor. Su trabajo es preguntarse: ¿esta solución respeta la spec? Si no, veto.

    Historias que sirven como espejo

    Junior + Copilot = demo en 48h. Producción = caos. Reescritura 3 semanas.

    Mismo caso con spec: plan en 2 días + Claude para contratos + Copilot para implementación respetando interfaces = demo en 48h. Integración estable. Diferencia: disciplina.

    Metáfora corta y pegadiza

    La spec es el embudo; la IA es la manguera. Sin embudo, el agua corre por todos lados. Con embudo, llega donde debe.

    Cuándo no necesitas spec rígida

    Sí, hay espacio para improvisar. Para generar mocks, para prototipos exploratorios o pequeñas refactors locales. Pero regla práctica: si tocas contratos (APIs, DB, auth, infra), necesitas spec. Punto.

    Checklist rápido antes de pedir código a la IA

    • ¿Existe SPEC.md en la raíz?
    • ¿Hay interfaces/contractos definidos?
    • ¿Hay reglas de seguridad básicas?
    • ¿El prompt pide tests y ejemplos?
    • ¿Se solicitó plan paso a paso y fue aprobado?

    Si respondes no a cualquiera, NO pidas código aún.

    Urgencia real: deuda técnica multiplica costes

    Cada PR aceptado sin spec es una apuesta. Adivina quién paga si pierde la apuesta: tu equipo. La deuda técnica no se desintegra con buenas intenciones. Se compone. Actuar ahora cuesta horas. Rehacer después cuesta semanas, o clientes.

    CTA simple y directo

    Haz esto en los próximos 60 minutos: crea SPEC.md en la raíz con las seis secciones mínimas que te di. Respóndeme con “Quiero la plantilla” y te la mando lista para pegar en tu repo.

    Cierre que no cierra (a propósito)

    Si sigues pensando que la IA es una varita mágica, es tu opción. Tienes otra: gobernarla. La spec es la forma más barata de gobernarla. No es cómoda. Es efectiva. Y esto no acaba aquí: si quieres, te doy la plantilla, un prompt maestro listo para Claude y un .cursorrules de ejemplo. Dime cuál quieres y te lo envío ahora. Tus commits —y tu equipo dentro de seis meses— lo agradecerán.

    Dominicode Labs

    Si trabajas con automatización, agentes o workflows y quieres ejemplos prácticos de especificaciones y .cursorrules, revisa los recursos disponibles en Dominicode Labs. Es una continuación lógica para equipos que buscan convertir experimentos rápidos en procesos repetibles y seguros.

    FAQ

    ¿Qué es una SPEC.md y por qué es necesaria?

    Una SPEC.md es un archivo en la raíz del repositorio que define objetivo, stack, reglas innegociables, contratos y criterios de aceptación. Es necesaria para alinear generación de código automática con las restricciones del negocio y evitar decisiones improvisadas que generen deuda técnica.

    ¿Cuándo puedo pedir código sin spec?

    Para prototipos exploratorios, mocks o pequeños refactors locales. Si el cambio afecta APIs, DB, auth o infra, siempre usar spec. Esa es la regla práctica del artículo.

    ¿Cómo garantizo que la IA respete los contratos?

    Publica interfaces TypeScript, OpenAPI o esquemas en el repo antes de pedir código. Exige tests que validen esos contratos y revisa que las implementaciones pasen los tests de integración definidos en la spec.

    ¿Qué contiene un criterio de aceptación sólido?

    Entradas y salidas esperadas, límites de rendimiento (ej. tiempo máximo 500ms), condiciones de error y tests de integración que validen el comportamiento en casos válidos e inválidos.

    ¿Quién debe ser responsable de la spec?

    Responsables claros: Tech Lead y Product Owner. En el ejemplo: Tech Lead: @ana, Owner: @carlos. Debe estar versionada en el repo y ser lo primero que lea cualquier agente automatizado.

    ¿Cómo auditar seguridad en dependencias sugeridas por IA?

    No introducir nuevas dependencias sin revisión de seguridad: CVE-check, análisis de licencia y una prueba mínima en entorno aislado. La spec puede imponer un máximo de dependencias nuevas sin revisión.

  • Cómo la librería sin código redefine la automatización en desarrollo

    Cómo la librería sin código redefine la automatización en desarrollo

    Tiempo estimado de lectura: 5 min

    Ideas clave

    • Tests como IP: la suite de tests y la especificación pasan a ser el activo más valioso.
    • Aceleración parcial: los agentes cubren rápidamente la mayor parte, pero el último 10% exige juicio humano y arquitectura.
    • Arquitectura y desacoplo: sin contratos claros, las correcciones que arreglan un test pueden romper otros.
    • Proceso recomendado: invertir en specs y tests antes de delegar a agentes; mantener CI y revisiones humanas.

     

    So welcome. Uh I was invited here today to talk about a project I launched which was a software library with no code

    Introducción breve

    Drew Brunig publicó una librería “sin código” —solo especificación, tests (≈750) y un prompt de instalación— y el resultado no fue sólo viralidad: fue una lección práctica sobre qué parte del trabajo de ingeniería sigue siendo inevitable y cuál puede automatizarse con agentes. Este artículo organiza esos aprendizajes y aporta criterio técnico aplicable a equipos que piensan en Spec‑Driven Development con IA.

    Resumen rápido (lectores con prisa)

    Qué es: un enfoque donde la especificación y la suite de tests definen el comportamiento; los agentes generan la implementación.

    Cuándo usarlo: para acelerar prototipos y reimplementaciones cuando hay tests extensivos y contratos claros.

    Por qué importa: desplaza el valor hacia quien diseña tests y specs; reduce el trabajo manual inicial pero no elimina la necesidad de arquitectura y revisión humana.

    ¿Por qué la librería sin código fue relevante?

    El experimento es instructivo porque separó tres capas que normalmente vienen entremezcladas:

    • Intención (spec en Markdown).
    • Validación (tests de conformidad en YAML).
    • Implementación (el artefacto que aquí se delega a agentes).

    Al entregar intención y validación como artefactos primarios, Brunig probó qué tanto del trabajo de implementación es reproducible por LLMs y qué partes siguen exigiendo juicio humano y arquitectura.

    Evidencia práctica y proyectos comparables

    Proyectos recientes muestran el patrón a escala:

    • Vercel/just‑bash (reimplementación de comportamiento Bash con tests generados desde shell reales).
    • Reimplementaciones de CPython en Rust (uso intensivo de la suite de tests de CPython).
    • Experimentos de Anthropic (multi‑agent para construir un compilador C, con inversión significativa en tokens).

    Fuentes útiles: repositorios y suites de tests en GitHub, ejemplo: CPython, y artículos corporativos como los de Anthropic.

    Cuatro aprendizajes técnicos que importan hoy

    1) Los tests son la nueva propiedad intelectual

    La parte más valiosa deja de ser el código y pasa a ser la suite de tests y la especificación que define exactamente el comportamiento. Construir tests exhaustivos es caro y requiere dominio del dominio. No es trabajo trivial que se “externalice” a la IA sin invertir en diseño de casos límite.

    2) La aceleración inicial es real; la finalización no lo es

    Los agentes cumplen los primeros grandes hitos rápidamente: el 80–90% funcional puede aparecer en poco tiempo. El último 10% (reglas de borde, consistencia, rendimiento, seguridad) exige iteración humana, diseño arquitectónico y pruebas adicionales.

    3) La arquitectura es el verdadero cuello de botella

    Cuando el sistema crece, los cambios locales producen regresiones globales. En Anthropic vieron cómo arreglar un test rompía otro. Los LLMs actuales tienden a reaccionar al test que falla sin razonar sobre el acoplamiento global. Para evitar bucles de regresión necesitas módulos desacoplados, contratos claros e invariantes explícitas.

    4) El multi‑agent development exige paralelismo arquitectónico

    Para que múltiples agentes trabajen sin colisión, el código debe dividirse en módulos con APIs limpias y dependencias mínimas. Diseñar para desarrollo paralelo (contratos, stubs, simuladores de I/O) es un trabajo humano previo que habilita la escala con agentes.

    Implicaciones prácticas para equipos y líderes técnicos

    • Invierte primero en especificaciones y tests antes de desplegar agentes. Los tests son la palanca que convierte IA en automatización fiable.
    • Prioriza arquitectura modular: si un área del código requiere conocer todo el sistema para cambiarla, no será buena candidata para delegar a agentes.
    • Mantén el ciclo implementación→spec→test iterativo: la implementación te enseña sobre casos no anticipados y mejora la spec.
    • Automatiza CI con pruebas de regresión estrictas: cada PR generado por un agente debe pasar un pipeline riguroso antes de merge.

    Patrón de despliegue recomendado (práctico)

    1. Definir spec y escribir tests automáticos (TDD extendido).
    2. Probar localmente con agentes en entorno aislado (sandboxes, contenedores).
    3. Validar outputs en CI paralelo a los tests humanos.
    4. Hacer revisiones arquitectónicas humanas en cada salto de confianza (no sólo revisar diffs).

    Conclusión con criterio

    El experimento de la librería sin código no demuestra que el código vaya a desaparecer; demuestra que el valor en ingeniería se está desplazando hacia quien diseña la intención y la validación. Para DominiCode y equipos serios, eso significa dedicar recursos a especificaciones, suites de tests y arquitectura: cuando esas tres piezas están bien hechas, los agentes son aceleradores poderosos. Si no, introducen velocidad sin control y deuda técnica más rápido que nunca.

    Referencias y lectura adicional

    Para equipos que evalúan integrar agentes y workflows automáticos en su ciclo, una continuidad natural es explorar iniciativas experimentales y herramientas internas; una referencia útil para esos experimentos es Dominicode Labs, que agrupa instalaciones y guías para prototipado con agentes y testing automatizado.

    FAQ

    ¿Qué significa “librería sin código” en este contexto?

    Se refiere a un artefacto donde la especificación y la suite de tests son los insumos primarios y la implementación es generada por agentes (LLMs), en lugar de entregar código escrito manualmente.

    ¿Por qué los tests se consideran propiedad intelectual?

    Porque definen con precisión el comportamiento esperado. Una suite de tests bien diseñada encapsula conocimiento del dominio y casos límite que permiten reproducir o proteger la funcionalidad independientemente del código.

    ¿En qué casos es adecuado delegar implementación a agentes?

    Cuando existe una especificación clara y una suite de tests robusta que cubre los escenarios críticos. También es más adecuado en áreas modulares y poco acopladas donde el riesgo de regresión global es menor.

    ¿Cómo se evitan regresiones en desarrollos multi‑agent?

    Mediante módulos desacoplados, contratos explícitos, tests de regresión estrictos y pipelines CI que validen cada cambio generado por agentes antes del merge. Las revisiones arquitectónicas humanas siguen siendo necesarias.

    ¿Qué rol juegan las revisiones humanas?

    Las revisiones humanas validan diseño arquitectónico, casos límite no cubiertos por tests y decisiones de seguridad o rendimiento. Son críticas en los saltos de confianza donde un agente no puede evaluar impacto sistémico.

    ¿Cuál es el primer paso práctico para adoptar este enfoque?

    Invertir en escribir especificaciones claras y una suite de tests automatizados que cubran comportamientos clave, antes de encargar a agentes la generación de código o refactorizaciones.

     

  • Cómo implementar Spec Driven Development para mejorar la productividad

    Cómo implementar Spec Driven Development para mejorar la productividad

    Cómo podemos implementar (SDD) Spec Driven Development en nuestro proyecto?

    En las primeras líneas: cómo podemos implementar (SDD) Spec Driven Development en nuestro proyecto? Se hace escribiendo especificaciones ejecutables antes del código, usándolas como entrada para generación de código, pruebas y validación automática.

    Tiempo estimado de lectura: 6 min

    • Ideas clave:
    • Escribe especificaciones ejecutables antes del código y úsalas como contratos vivos.
    • Mantén las specs en el repo (/specs) y automatiza mocks, SDKs y contract tests.
    • Usa herramientas como Prism, Spectral, OpenAPI Generator, Dredd o Pact.
    • Haz que la spec sea la primera PR y que el CI valide la conformidad con la spec.

    Resumen rápido (lectores con prisa)

    Spec Driven Development (SDD) consiste en escribir especificaciones ejecutables antes del código. Úsalas como contrato: mocks, SDKs y tests se generan desde la spec. Implementa Spectral en pre-commit, Prism para mocks, y Dredd/Pact en CI para validar contrato contra la API real.

    Cómo podemos implementar (SDD) Spec Driven Development en nuestro proyecto? — enfoque pragmático

    Si tu equipo quiere dejar de pelearse en la integración y aprovechar agentes de IA sin acabar con código que no cumple lo pactado, la respuesta es: implementar SDD ahora mismo. “Cómo podemos implementar (SDD) Spec Driven Development en nuestro proyecto?” no es una abstracción; es una checklist práctica con impacto inmediato en productividad y calidad.

    1) Define el nivel de SDD que necesitas

    • Spec-First: spec temporal para prototipos.
    • Spec-Anchored (recomendado): spec vive en el repo y se mantiene viva.
    • Spec-as-Source: la spec es la única verdad; requiere alto grado de automatización.

    Referencias: Thoughtworks Radar, Martin Fowler.

    2) Estándar mínimo: formato y carpeta

    • APIs → OpenAPI 3.1: OpenAPI 3.1
    • Lógica de negocio → Markdown estructurado: /specs/<feature>.spec.md con Contexto, Interfaces, Invariantes y Scenarios (Given/When/Then).
    • Guarda todas las specs en /specs del repo.

    3) Herramientas que automatizan la spec-run

    • Prism — Mocking. Ejemplo: npx @stoplight/prism mock ./specs/payments.yaml
    • Spectral — Lint de spec. Ejemplo: npx @stoplight/spectral-cli lint ./specs/payments.yaml
    • OpenAPI Generator — Generación de SDKs. Ejemplo: openapi-generator-cli generate -i specs/payments.yaml -g typescript-fetch -o src/api-client

    4) Flujo de trabajo diario (Spec-Anchored)

    1. Escribe o actualiza la spec en /specs.
    2. Genera mocks y SDKs automáticos. Frontend consume mock; backend implementa.
    3. Pide a tu agente de IA (Cursor, Copilot Chat, Claude) que use la spec como contexto para generar código y tests. Prompt explícito: “Implementa la spec specs/payroll.spec.md en TypeScript. Cumple las invariantes y genera tests Jest basados en los escenarios Given/When/Then.”
    4. Contract testing en CI: Dredd o Pact comparan spec vs API real.
    5. Si cambian requisitos, actualiza la spec primero; luego regenera artefactos.

    5) Pipelines y validación automática

    Pre-commit: Spectral valida specs.

    CI: pasos obligatorios — lint spec → build mock → contract tests → generar SDK → pruebas unitarias/e2e.

    Ejemplo GitHub Action (snippet):

    jobs:
      validate_spec:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - run: npx @stoplight/spectral-cli lint ./specs/openapi.yaml
      contract_test:
        runs-on: ubuntu-latest
        needs: validate_spec
        steps:
          - run: npx dredd ./specs/openapi.yaml http://staging-api:3000

    6) Generación de pruebas desde la spec

    No delegues la creación de tests al azar. Genera suites automáticas (unit/e2e) basadas en Given/When/Then definidas en la spec. Pide a la IA que produzca:

    • Tests felices e infelices.
    • Tests de invariantes (por ejemplo: “neto nunca negativo”).
    • Tests contractuales (comprobación de códigos HTTP y shape del body).

    7) Métricas y control de regresión

    Mide:

    • Tiempo front→back para integrar una API (debería reducirse).
    • Número de bugs por “cambio de contrato”.
    • % de PRs que fallan en contract tests.

    Si aumentan errores, obliga a que la spec sea la primera PR a modificar.

    Errores comunes y cómo evitarlos

    • Specs vagas: exige schemas y ejemplos concretos (JSON Schema).
    • Specs obsoletas: impón bloqueo en CI si la implementación y spec divergen.
    • Sobrespecificar: no todo necesita spec-as-source; empieza por endpoints críticos.

    Herramientas mencionadas

    Checklist de adopción (acción inmediata)

    1. Crear /specs y subir una spec OpenAPI o .spec.md para la próxima feature.
    2. Añadir Spectral en pre-commit.
    3. Levantar Prism para mocks y obligar al frontend a consumir el mock durante 48 horas.
    4. Integrar Dredd/Pact en CI para contract tests.
    5. Generar SDKs con OpenAPI Generator y conectar al frontend.
    6. Medir: reducción de bloqueos front/back y tasa de fallos por contrato.

    Conclusión

    Implementar Spec Driven Development en tu proyecto no es un ejercicio académico: es la estrategia práctica para convertir specs en contratos ejecutables que alimentan agentes de IA y pipelines automatizados. Empieza por una API crítica, haz que la spec sea la primera línea que se edite y obliga al CI a validar que el código respeta ese contrato. En pocas semanas tendrás menos reuniones de emergencia y más despliegues confiables.

    Para equipos interesados en automatización aplicada e integración con agentes e IA, una continuación práctica puede encontrarse en Dominicode Labs. Explora ejemplos de pipelines y plantillas de specs para acelerar la adopción.

    FAQ

    ¿Qué es Spec Driven Development (SDD)?

    SDD es una práctica que consiste en escribir especificaciones ejecutables antes del código y usarlas como contratos. Desde la spec se generan mocks, SDKs y suites de pruebas que validan la implementación.

    ¿Cuándo debería empezar con SDD?

    Empieza por una API crítica o un flujo que genere frecuentes bloqueos front/back. Implementa una spec temporal (Spec-First) para validar la idea, luego migrar a Spec-Anchored.

    ¿Qué herramientas son imprescindibles para empezar?

    Al menos: OpenAPI 3.1 para APIs, Prism para mocks y Spectral para lint. Para contract testing, Dredd o Pact.

    ¿Cómo integro specs en mi CI?

    Añade pasos en CI: lint de spec (Spectral), levantar mocks/build del contrato, ejecutar contract tests (Dredd/Pact) contra el staging, y bloquear merges si fallan.

    ¿Cómo utilizo IA con specs sin perder control?

    Provee la spec al agente como contexto y exige prompts explícitos (por ejemplo: “Implementa la spec X en TypeScript y genera tests Jest según Given/When/Then”). Valida automáticamente los artefactos generados contra la spec.

    ¿Qué métricas debo monitorizar?

    Tiempo front→back para integrar APIs, número de bugs por cambio de contrato y porcentaje de PRs que fallan en contract tests. Si empeoran, fuerza que la spec sea la primera PR a cambiar.