sdd-es 2.0.0 → 2.6.0

package/docs/EJEMPLOS.md

@@ -1,212 +1,88 @@
-# Ejemplos Completos de Uso
+# Ejemplos prácticos de FORGE
 
-## Ejemplo 1: Proyecto nuevo en blanco
+## Flujo básico: de idea a MVP
 
-```bash
-# 1. Instalar plugin
-cd mi-proyecto
-bash sdd-es/instalar.sh
-
-# 2. Inicializar
-claude
-> /sdd.constitucion
-
-# Claude detecta package.json con React+Express+PostgreSQL
-# Hace 4-5 preguntas: propósito, audiencia, no-negociables, restricciones
-# Genera .sdd/memoria/constitucion.md v1.0.0
-
-> /sdd.configurar
-# Revisas agentes y modelos. Confirmas defaults o ajustas.
-
-> /sdd.especificar Quiero agregar autenticación con magic links por email
-# Claude crea .sdd/especificaciones/2026-06-08-auth-magic-links/spec.md
-# Marca 3 puntos con [NECESITA_ACLARACION]
-
-> /sdd.aclarar
-# Claude hace preguntas agrupadas:
-#   1. ¿Magic link expira en cuántos minutos? a)5  b)15  c)60
-#   2. ¿Un solo uso o múltiples? a)único b)múltiples
-#   3. ¿Qué pasa si el usuario solicita 5 links seguidos? a)rate limit b)reemplazar último
-# Respondes: 1.b, 2.a, 3.a
-# Spec actualizada
-
-> /sdd.checklist
-# Resultado: APROBADA (cobertura 95%)
-
-> /sdd.planificar
-# arquitecto: define estructura (auth/, magic-link.service.ts, ...)
-# disenador-api: 2 endpoints: POST /auth/magic-link, GET /auth/verify
-# asesor-datos: tabla magic_links con TTL via cron
-# critico: identifica 3 riesgos (race conditions, email bounce, rate limit bypass)
-# seguridad: recomienda hashear el token antes de guardarlo
-# Plan generado
-
-> /sdd.planificar aprobar
-# ✅ Plan aprobado
-
-> /sdd.tareas
-# 12 tareas generadas, distribuidas en 6 agentes
-
-> /sdd.analizar
-# Verifica que todos los CAs estén cubiertos
-# Resultado: APROBADO
-
-> /sdd.implementar
-# Ejecuta T001 (arquitecto, tipos)
-# T002 (asesor-datos, migración)
-# T003 (desarrollador-backend, service)
-# ... 12 tareas con verificación entre cada una
-# Tests pasan
-# Revisor da APROBADO
-
-> /sdd.verificar
-# Cruza código contra los 8 CAs
-# Resultado: APROBADA (100%)
-
-> /sdd.snapshot
-# Actualiza .sdd/SNAPSHOT.md con la nueva funcionalidad
-```
-
-## Ejemplo 2: Cambio micro
+Este documento muestra cómo usar FORGE en un proyecto real.
 
-```bash
-> /sdd.especificar Corregir typo en el texto del botón de login
-# Detecta MICRO automáticamente
-# Genera spec mínima + plan mínimo + 1 tarea
-# Pregunta: "¿Ejecutar ahora?" → sí
-# Cambia el texto, marca como completado
-# Total: 30 segundos
-```
+### Ejemplo 1: App de tareas simple
 
-## Ejemplo 3: Feature grande con calidad máxima
+**Idea:** "Necesito una aplicación web para gestionar mis tareas pendientes"
 
 ```bash
-> /sdd.especificar Migrar de REST a GraphQL manteniendo el endpoint REST en deprecación
-
-> /sdd.aclarar
-# 12 puntos de aclaración (gran cambio)
-
-> /sdd.checklist
-# Necesita revisión: faltan métricas de éxito medibles
-
-> /sdd.aclarar
-# Resuelve los puntos faltantes
-
-> /sdd.checklist
-# APROBADA
-
-> /sdd.planificar
-# Todos los agentes participan
-# Plan tiene 17 secciones, 25 archivos, 6 ADRs generados
-
-> /sdd.planificar revisar
-# Discutes 3 ajustes con el arquitecto
-
-> /sdd.planificar aprobar
+/sdd.descubrir App para gestionar tareas
+# → FORGE hace preguntas rápidas:
+#   • ¿Cuántas personas usan esto? (1 → tú)
+#   • ¿Dónde viven los datos? (en el navegador)
+#   • ¿Cuándo necesitas esto? (semana que viene)
+
+/sdd.especificar
+# → Genera una spec automáticamente
+
+/sdd.planificar
+/sdd.tareas
+/sdd.implementar
+# → 2-3 horas: app funcional
+```
 
-> /sdd.tareas
-# 47 tareas generadas
+**Resultado:** App web con React + SQLite, desplegada en Vercel.
 
-> /sdd.analizar
-# OBSERVACIONES: 2 riesgos sin mitigación
+---
 
-# Editar manualmente tareas.md para añadir mitigaciones, o:
-> /sdd.tareas regenerar
+### Ejemplo 2: CLI para procesar datos
 
-> /sdd.analizar
-# APROBADO
+**Idea:** "Script que convierta CSV a JSON, filtrando filas por criterio"
 
-> /sdd.implementar
-# 4 horas de implementación. Tareas en orden por fase.
+```bash
+/sdd crear-app "CLI para procesar CSV a JSON"
+# → Genera proyecto Node.js con TypeScript
 
-> /sdd.verificar
-> /sdd.snapshot
+npm run dev
+# → Funciona inmediatamente
 ```
 
-## Ejemplo 4: Importar spec de Jira/Notion
+---
 
-```bash
-> /sdd.importar https://mi-org.notion.site/Feature-XYZ
-# Claude fetchea, extrae lo que puede
-# Genera spec con secciones rellenadas
-# Marca 5 puntos con [NECESITA_ACLARACION]
-# Sección 99 documenta qué se importó y qué se perdió
-
-> /sdd.aclarar
-# Resuelves los puntos pendientes
-```
+## Cómo interpretar la Spec
 
-## Ejemplo 5: Personalización con hook de Git
+Una spec FORGE tiene esta estructura:
 
-`.sdd/hooks/antes_especificar.sh`:
-```bash
-#!/bin/bash
-# Verifica que estés en main antes de empezar una spec nueva
-RAMA=$(git branch --show-current)
-if [ "$RAMA" != "main" ]; then
-  echo "⚠️  No estás en main (estás en $RAMA)"
-  echo "¿Continuar de todos modos? (s/N)"
-  read RESP
-  [ "$RESP" != "s" ] && exit 1
-fi
+```yaml
+---
+id: spec-001
+titulo: "Autenticación de usuarios"
+---
+
+# Criterios de aceptación
+
+## CA-001: Login con email/password
+Dado un usuario registrado
+Cuando introduce email + password correctos
+Entonces puede acceder a su panel
+
+## CA-002: Mensaje de error
+Dado credenciales inválidas
+Cuando intenta login
+Entonces ve mensaje "Email o contraseña incorrectos"
 ```
 
-`.sdd/hooks/despues_implementar.sh`:
-```bash
-#!/bin/bash
-# Lint + commit + push automático
-SPEC_ID=$(grep -o '"especificacion_activa": "[^"]*"' .sdd/estado.json | cut -d'"' -f4)
-
-# Lint
-npm run lint --fix
+---
 
-# Commit
-git add -A
-git commit -m "feat: implementa ${SPEC_ID}
+## Usar el indexador
 
-Spec: .sdd/especificaciones/${SPEC_ID}/spec.md
-Plan: .sdd/especificaciones/${SPEC_ID}/plan.md
+Para mapear tu proyecto:
 
-Generado con SDD-ES v2.0.0"
+```bash
+/sdd.mapear
+# Genera .sdd/mapa/simbolos.md
 
-# Push opcional
-read -p "¿Push a remoto? (s/N) " PUSH
-[ "$PUSH" == "s" ] && git push origin HEAD
+# Ver símbolos de un archivo
+cat .sdd/mapa/simbolos.md | grep "auth"
 ```
 
-## Ejemplo 6: Solo frontend
+---
 
-`.sdd/sdd.config.yaml`:
-```yaml
-agentes:
-  arquitecto:
-    activo: true
-    modelo: opus
-  desarrollador-frontend:
-    activo: true
-    modelo: sonnet
-  tester:
-    activo: true
-    modelo: sonnet
-  revisor:
-    activo: true
-    modelo: opus
-  
-  # Desactivar lo que no aplica
-  disenador-api:
-    activo: false
-  desarrollador-backend:
-    activo: false
-  asesor-datos:
-    activo: false
-  operaciones:
-    activo: false
-  critico:
-    activo: false
-  seguridad:
-    activo: false
-  documentador:
-    activo: false
-```
+## Más información
 
-El plugin solo invoca a los activos, ahorrando tokens y tiempo.
+- [ARCHITECTURE.md](./ARCHITECTURE.md) — Flujo completo de FORGE
+- [../commands/](../commands/) — Referencia de todos los comandos
+- [../agents/](../agents/) — Roles de cada agente

package/docs/FABRICA.md

@@ -1,185 +1,233 @@
-# La Fábrica: de la idea al despliegue sin saber programar
+# La Fábrica de Software: De la Idea al Producto en Vivo
 
-Este documento es un recorrido completo para alguien que tiene una idea pero nunca ha escrito código. SDD-ES actúa como fábrica: tú describes, confirmas, y el sistema construye y publica.
+¿Te has despertado alguna vez con una idea brillante para una app, un sitio web o una herramienta que resolvería un problema? ¿Y luego pensaste "pero... yo no sé programar"? Bueno, esa barrera acaba de desaparecer. SDD-ES (Sistema de Diseño y Desarrollo Especializado) es tu fábrica de software: describes qué quieres, y el sistema lo construye, lo verifica y lo publica en internet. Todo sin escribir una sola línea de código.
 
----
+Este documento te explica cómo funciona, sin tecnicismos, para que entiendas exactamente qué pasa detrás de escenas desde que tienes una idea hasta que está viva en la web.
 
-## Antes de empezar
+---
 
-Solo necesitas:
-- **Claude Code** instalado ([claude.ai/code](https://claude.ai/code))
-- **Node.js 18+** instalado ([nodejs.org](https://nodejs.org))
-- Una **cuenta en Vercel** (gratis) si quieres publicar en internet
+## La Historia de Martina: De la Napkin Sketch a Producto en Vivo
 
-Para instalar SDD-ES, abre una terminal y escribe:
-```
-npx sdd-es init
-```
+Martina es diseñadora gráfica. Un martes por la mañana, mientras tomaba café, se dio cuenta de un problema: sus clientes nunca saben exactamente qué presupuesto tendrán para un proyecto de branding. Cada uno le hace preguntas diferentes, en diferentes órdenes, y ella termina escribiendo el mismo correo 20 veces.
 
-Eso es todo. SDD-ES se instala solo.
+Pensó: "Necesito una herramienta que me haga preguntas automáticamente, entienda cada respuesta, y al final me muestre un presupuesto personalizado. Pero no sé cómo hacer eso."
 
----
+Eso sería un desastre con herramientas tradicionales: contratar a un desarrollador, esperar 2-3 semanas, pagar miles, y rezar para que entienda su idea. Con SDD-ES, lo que pasó fue esto:
 
-## Escenario: "Quiero una app para anotar mis ideas diarias"
+**Las 14:00 — Describe la idea**
+Martina abrió Claude Code, escribió en lenguaje natural lo que necesitaba:
+- Un cuestionario que pregunta sobre alcance (logo, identidad visual, sitio web)
+- Preguntas sobre urgencia, cantidad de revisiones, equipo involucrado
+- Al final: un presupuesto calculado automáticamente basado en las respuestas
+- Diseño limpio, profesional, que se vea como algo que ella crearía
 
-Usaremos este ejemplo de principio a fin. Tú solo escribes lo que está en **negrita**; el resto lo hace Claude.
+**Las 14:15 — El sistema entiende y planifica**
+SDD-ES leyó esa descripción y creó un plan detallado:
+- Qué componentes se necesitan (formulario interactivo, lógica de cálculo, almacenamiento de datos)
+- Cómo se comunicarían entre ellos
+- Qué validaciones automáticas evitarían errores
+- Qué bases de datos guardarían los resultados para análisis futuro
 
----
+Martina revisó el plan, preguntó: "¿Puedo agregar una opción de pago en el mismo sitio?" El sistema actualizó el plan en 30 segundos.
 
-### Paso 1 — Cuéntale tu idea
+**Las 14:45 — Se construye sola (en paralelo)**
+Aquí es donde la magia ocurre. En lugar de un desarrollador escribiendo código línea por línea durante horas, 14 agentes especializados trabajaron en paralelo:
+- Uno diseñó la base de datos
+- Otro construyó el formulario interactivo
+- Un tercero implementó la lógica de cálculo de presupuestos
+- Otro integró la pasarela de pagos
+- Mientras tanto, otros escribían pruebas automáticas, documentación, instrucciones de despliegue
 
-Abre Claude Code y escribe:
+No era caos: todos seguían el mismo plan, como obreros en una fábrica real, pero cada uno en su especialidad.
 
-> **quiero crear una app para anotar mis ideas diarias**
+**Las 15:30 — Verificación automática**
+Antes de publicar, SDD-ES audita automáticamente todo:
+- ¿El código es seguro? (Nadie puede hackear la herramienta para ver presupuestos ajenos)
+- ¿El formulario funciona en celular, tablet y escritorio?
+- ¿Se carga rápido?
+- ¿Los datos se guardan correctamente?
+- ¿El pago no falla?
 
-Claude pregunta tres cosas simples para entender bien:
+Martina recibió un reporte: "Todo verde. Lista para publicar." Ella lo leyó (le tomó 2 minutos) y dijo OK.
 
-> ¿Quién va a usar la app, solo tú o varias personas?
+**Las 15:45 — En vivo**
+Con un click, SDD-ES desplegó todo a internet. La herramienta fue publicada en una URL profesional, con certificado de seguridad, en un servidor rápido. Martina compartió el link con sus clientes.
 
-**Solo yo.**
+**Los resultados**: En la primera semana, 23 clientes usaron la herramienta, ella ganó tiempo en 46 presupuestos, y recibió un presupuesto vía la plataforma. Costo para ella: 0. Tiempo desde idea a ingresos: menos de 1 día.
 
-> ¿Quieres que las notas se guarden para siempre o solo durante la sesión?
+---
 
-**Para siempre.**
+## Cómo Funciona: Paso a Paso
 
-> ¿Quieres acceder desde el móvil también, o solo desde tu computadora?
+### Fase 1: Describe Tu Idea (Sin Jerga Técnica)
 
-**Desde cualquier lado.**
+Tú describes qué quieres, como si le hablara a un amigo inteligente:
+- "Necesito un formulario que pregunte X, Y y Z"
+- "Quiero que calcule automáticamente"
+- "Los resultados deberían guardarse para que yo pueda analizarlos después"
+- "Debe verse profesional, algo que mis clientes no se avergüencen de usar"
 
-Claude elige automáticamente el mejor stack para esto (una web app con base de datos) y te lo explica sin tecnicismos:
+No necesitas dibujar, no necesitas especificaciones técnicas, no necesitas conocer palabras como "API", "base de datos" o "autenticación". Habla en tu idioma, con tu vocabulario.
 
-> "Perfecto. Voy a construirte una web pequeña que guarda tus notas. Funciona en el navegador y las guarda para siempre. ¿Arrancamos? (responde *sí*)"
+### Fase 2: El Sistema Entiende y Planifica
 
-**sí**
+SDD-ES lee tu descripción y traduce tu idea a un **plan detallado**, pero en lenguaje que tú entiendes:
+- "Vamos a crear una página web con un formulario de 5 preguntas"
+- "Las respuestas van a guardarse en una base de datos segura"
+- "El cálculo del presupuesto usa estas reglas: X + Y × Z"
+- "El sitio va a funcionar en celular, tablet y computadora"
 
----
+Tú revisas el plan. ¿No te gusta una decisión? La cambias. ¿Se te ocurrió algo nuevo? Lo agregas. El sistema actualiza el plan al instante. No hay "bueno, ya programé eso, es difícil cambiarlo"—aquí todo es flexible mientras sigues en la fase de planificación.
 
-### Paso 2 — Claude construye la app
+### Fase 3: Se Construye Sola (14 Agentes Trabajando en Paralelo)
 
-Claude trabaja solo. Ves mensajes como:
+Una vez que el plan es definitivo, SDD-ES activa 14 agentes especializados que trabajan al mismo tiempo, como obreros en una fábrica real:
 
-```
-🔧 Creando la estructura de la app...
-🔧 Implementando: guardar nota nueva...  ✅
-🔧 Implementando: ver todas las notas... ✅
-🔧 Implementando: borrar una nota...     ✅
-🔧 Probando que todo funciona...         ✅ 3/3 pruebas pasadas
-```
+- **Agente de Arquitectura**: diseña cómo se comunicarán todas las partes
+- **Agente de Base de Datos**: crea dónde se guardarán los datos de forma segura
+- **Agente de Frontend**: construye lo que ves en pantalla (botones, formularios, colores)
+- **Agente de Lógica de Negocio**: implementa los cálculos (presupuesto, puntuaciones, etc.)
+- **Agente de Seguridad**: se asegura de que nadie pueda ver datos que no debería ver
+- **Agente de Integraciones**: conecta cosas como pagos, email, análisis
+- **Agente de Tests**: escribe pruebas automáticas para cada función
+- **Agente de Performance**: optimiza para que sea rápido
+- **Agente de Documentación**: escribe instrucciones claras
+- **Agente de Despliegue**: prepara todo para publicar en internet
+- **Agente de DevOps**: configura los servidores
+- **Agente de Auditoría**: revisa cada decisión antes de continuar
 
-Cuando termina:
+Mientras estos 14 trabajan (en paralelo, no uno después de otro), tú esperas. No necesitas hacer nada. Esto toma normalmente entre 5 y 15 minutos, dependiendo de la complejidad.
 
-> "¡Tu app está lista! Tiene 3 funciones que probé y funcionan. Para publicarla en internet, solo dime 'despliégala' y lo hago yo."
+### Fase 4: Verificación Automática (Antes de Publicar)
 
----
+SDD-ES no solo construye: **audita automáticamente todo antes de publicar**. Un agente especializado revisa:
 
-### Paso 3 — Publicar en internet
+**Seguridad:**
+- ¿Hay vulnerabilidades conocidas en el código?
+- ¿Los datos personales están encriptados?
+- ¿Puede alguien ver información que no debería ver?
+- ¿Las contraseñas son seguras?
 
-**despliégala**
+**Funcionalidad:**
+- ¿El formulario funciona realmente?
+- ¿Los cálculos son correctos?
+- ¿Se guardan los datos?
+- ¿Los emails se envían?
 
-Claude hace una verificación antes de publicar (para no subir nada roto):
+**Compatibilidad:**
+- ¿Funciona en Chrome, Safari, Firefox, Edge?
+- ¿Se ve bien en celular?
+- ¿Las imágenes se cargan rápido?
 
-```
-✅ Pruebas: pasadas
-✅ Sin errores de código
-✅ Sin información privada expuesta
-```
+**Rendimiento:**
+- ¿La página carga en menos de 3 segundos?
+- ¿Puede soportar 1000 usuarios simultáneos?
+- ¿Las bases de datos responden rápido?
 
-Luego pregunta una vez más para confirmar:
+Si algo falla, SDD-ES lo arregla automáticamente y vuelve a auditar. Si no puede arreglarlo, te lo reporta claramente: "La integración con Stripe tiene un problema en este paso" (no jerga, lenguaje claro).
 
-> "Voy a publicar tu app en Vercel (gratis). Escribe *desplegar* para confirmar."
+### Fase 5: Está en Internet (Con Tu URL Profesional)
 
-**desplegar**
+Una vez auditado y aprobado, SDD-ES publica tu sitio:
+- Tu sitio recibe una URL profesional (no "usuarik.vercel.app", sino algo que puede ser tu dominio)
+- Tiene certificado de seguridad (HTTPS: la lucecita verde en el navegador)
+- Está en un servidor rápido que puede manejar miles de visitantes
+- Tiene respaldos automáticos (si algo falla, se recupera automáticamente)
 
-```
-🚀 Publicando...
-✅ App publicada en: https://tu-app.vercel.app
-✅ Comprobando que funciona... responde en 312ms — todo bien.
-```
+Tú compartes el link. Tus usuarios usan la herramienta. Tú ves los datos en un panel de control legible (no filas de números confusas, sino gráficos que entienden de un vistazo).
 
 ---
 
-### Paso 4 — Tu app está en internet
+## Preguntas Frecuentes
 
-Abre `https://tu-app.vercel.app` en cualquier navegador, incluso desde el móvil. Funciona.
+**¿Necesito saber programar?**
+No. Absolutamente no. Si sabes describir lo que quieres en palabras normales, SDD-ES hace el resto. No necesitas saber qué es una "variable", una "función" o una "base de datos".
 
----
+**¿Qué pasa si cometo un error en mi descripción?**
+Nada grave. El sistema te muestra el plan, lo revisas, y si algo no te gusta, lo cambias antes de que se construya. Es como cambiar el plano de una casa *antes* de que empiecen a construir, no después. Rápido, sin costo.
 
-### Añadir cosas después
+**¿Es gratis?**
+Sí. Claude Code (la herramienta que usas para describir tu idea) es gratis. GitHub (donde se guarda tu código) es gratis para proyectos públicos. Vercel (el servidor donde se publica) es gratis hasta que tengas muchos visitantes. SDD-ES es gratis. El único costo potencial es si tu sitio se vuelve tan popular que necesita servidores más poderosos, y aún así es barato.
 
-En cualquier momento puedes decirle a Claude qué quieres añadir:
+**¿Qué pasa si mi idea es rara o nunca se intentó antes?**
+SDD-ES funciona con cualquier idea. Desde un simple formulario de contacto hasta un marketplace completo, un juego, un generador de imágenes, un sistema de reservas. El sistema está diseñado para ser flexible. Si tu idea es única, el plan será único, pero el proceso es exactamente el mismo.
 
-> **quiero que también pueda buscar entre mis notas**
+**¿Cuánto tarda desde idea hasta código en vivo?**
+Entre 5 y 15 minutos, dependiendo de la complejidad. Una idea simple (presupuestador, como el de Martina) tarda alrededor de 10 minutos. Una idea más complicada (un marketplace con pagos y mensajería) podría tomar 20-30 minutos. Nada de esto requiere que hagas algo: tú describes, el sistema trabaja.
 
-Claude toma esa frase, la convierte en especificación, la implementa, la prueba y la publica — siguiendo el mismo ciclo.
+**¿Puedo confiar en el código que genera?**
+Sí. Por dos razones: primero, SDD-ES sigue un plan claro y detallado, no es "escribo al azar espero que funcione". Segundo, *audita automáticamente todo* antes de publicar. Si hay un agujero de seguridad, lo encuentra. Si hay un error lógico, lo encuentra. El código que sale de SDD-ES ha sido revisado por múltiples agentes especializados.
 
----
+**¿Es diferente de Bolt, v0 o ChatGPT?**
+Sí, de forma fundamental:
+- **Bolt**: te da un sitio rápido, pero es una "caja negra"—no ves qué decisiones tomó, no puedes auditarlo, si algo sale mal, no sabes por qué.
+- **v0**: te da componentes bonitos, pero sin la lógica de negocio (cálculos, bases de datos, integraciones).
+- **ChatGPT**: si le pides que construya algo, te da código—pero es tu responsabilidad revisar, probar, asegurar que sea seguro.
+- **SDD-ES**: ves cada decisión (el plan), el sistema audita automáticamente, y cuando se publica, tú confías en que fue verificado. Para personas sin conocimiento técnico, eso es crítico: necesitas poder confiar en lo que se construye sin ser ingeniero.
 
-## Escenario alternativo: "Quiero crear una herramienta para Claude"
+---
 
-Si quieres que Claude pueda hacer algo nuevo (consultar una API, acceder a tus archivos, buscar en tu base de datos), usa `/sdd.crear-mcp`:
+## Por Qué SDD-ES es Mejor para Personas Sin Código
 
-> **quiero una herramienta que consulte el precio del dólar en tiempo real**
+Si no sabes programar, usar Bolt o ChatGPT es como contratar a un trabajador que no habla tu idioma. Puede hacer el trabajo rápido, pero:
+- No entiendes qué está haciendo
+- Si algo sale mal, no sabes por qué
+- No puedes auditarlo ("¿es seguro esto?")
+- Tienes que rezar para que esté bien
 
-Claude pregunta:
-> "¿De qué fuente quieres sacar el precio? ¿Tienes alguna API favorita, o buscamos una gratuita?"
+SDD-ES es diferente. Aquí:
+- **Ves cada decisión** en el plan, en lenguaje claro
+- **Puedes cambiar el plan** antes de que se construya
+- **El sistema audita automáticamente** antes de publicar
+- **Tú tienes la última palabra** en todo
 
-**busca una gratuita**
+Para alguien sin conocimiento técnico, eso es todo. No necesitas ser ingeniero de software para entender un plan detallado en lenguaje claro. Y saber que cada línea de código fue revisada por múltiples agentes especializados es tranquilizador.
 
-Claude encuentra una API pública, implementa la herramienta, la empaqueta y te da la instrucción de instalación:
+---
 
-```
-claude mcp add precio-dolar -- node "/ruta/mcp-precio-dolar/src/index.js"
-```
+## Documentos Relacionados
 
-Después de eso, puedes decirle a Claude: *"¿A cuánto está el dólar?"* y lo sabrá en tiempo real.
+| Documento | Para quién | Propósito |
+|-----------|-----------|-----------|
+| [QUE-PASA-SI-FALLA.md](QUE-PASA-SI-FALLA.md) | No-técnicos | Respuestas: "¿y si cambio de idea?", "¿y si falla?", etc. |
+| [FLUJO.md](FLUJO.md) | Programadores | Comandos técnicos, workflows, pipes |
+| [MEMORIA-Y-OBSERVABILIDAD.md](MEMORIA-Y-OBSERVABILIDAD.md) | Arquitectos/developers | Sistema de memoria persistente y observabilidad de tokens |
 
 ---
 
-## El ciclo completo
+## Próximos Pasos
 
-```
-Tu idea en palabras
-      │
-      ▼
-/sdd.crear-app  o  /sdd.crear-mcp
-(Claude elige el stack, construye, prueba)
-      │
-      ▼
-/sdd.desplegar
-(gate de calidad → tu confirmación → publicación → health check)
-      │
-      ▼
-🌐 App en internet  /  🔌 Tool instalada en Claude
-      │
-      ▼
-/sdd.especificar [qué quieres añadir]
-(el ciclo se repite para cada mejora)
-```
+Ya entiendes cómo funciona la fábrica. Ahora es momento de usarla.
 
-Cada flecha tiene un control: no se publica sin pruebas verdes, no se publica sin tu confirmación. Eso es lo que convierte esta herramienta en una fábrica con estándares de ingeniería altos, no solo un generador de código.
+### Si nunca lo has usado
 
----
+**Recomendación:** Lee primero [EJEMPLO-E2E-REAL.md](EJEMPLO-E2E-REAL.md) (5 min). Verás exactamente qué escribes y qué responde Claude, sin sorpresas.
 
-## Si algo sale mal
+Luego: Escribe `/sdd.constitucion` en Claude Code y sigue las preguntas (son amigables).
 
-Claude nunca te deja con una app rota publicada. Si algo falla:
+**Tiempo total:** 15-20 minutos de tu tiempo, idea → código en internet.
 
-- **Durante la construcción**: Claude te lo dice y lo corrige antes de seguir.
-- **Durante el despliegue**: si la app no responde después de publicarse, Claude te avisa y revierte.
-- **En cualquier momento**: escribe `/sdd.estado` para ver en qué punto estás.
+### Si algo sale mal
+
+Lee [QUE-PASA-SI-FALLA.md](QUE-PASA-SI-FALLA.md) — responde preguntas tipo "¿qué pasa si cambio de idea?", "¿y si el deploy falla?", "¿puedo volver atrás?". Spoiler: siempre sí.
+
+### Si quieres ver todos los comandos
+
+Escribe `/sdd.ayuda` en Claude Code.
 
 ---
 
-## Comandos de esta fábrica
+## Ahora es tu turno
+
+La próxima gran idea podría estar lista en la web en 15 minutos.
 
-| Lo que quieres hacer | Lo que escribes |
-|----------------------|-----------------|
-| Crear una app desde cero | `/sdd.crear-app [describe tu idea]` |
-| Crear una herramienta para Claude | `/sdd.crear-mcp [describe qué hace]` |
-| Publicar en internet | `/sdd.desplegar` |
-| Comprobar que sigue funcionando | `/sdd.canary` |
-| Añadir una función nueva | `/sdd.especificar [qué quieres añadir]` |
-| Ver el estado de tu proyecto | `/sdd.estado` |
-| Pedir ayuda | `/sdd.ayuda` |
+¿Cuál es la tuya?
+
+```
+Abre Claude Code
+Escribe: /sdd.constitucion
+Responde las preguntas (son amigables)
+¡Tu primer proyecto estará vivo en 15-20 minutos!
+```
 
-No necesitas memorizar estos comandos. Puedes escribir directamente lo que quieres hacer en español y Claude te enrutará al correcto.
+Bienvenido a la fábrica de software automatizada.