sdd-es 2.0.0 → 2.5.0

package/design-systems/warm-editorial/DESIGN.md

@@ -0,0 +1,221 @@
+# DESIGN SYSTEM: Warm Editorial
+
+> **Dirección**: Cálido, editorial, humano. Inspirado en revistas de calidad. Serif para display, sans-serif para cuerpo. Tonos tierra.
+
+---
+
+## 1. Visual Theme & Atmosphere
+
+Como una revista bien editada. Contenido primero, estructura visible. Tipografía como elemento de diseño.
+Cálido sin ser informal. Elegante sin ser frío.
+
+**Palabras clave**: editorial · cálido · legible · humano · curado · artesanal
+
+---
+
+## 2. Color Palette & Roles
+
+```css
+/* Fondos */
+--bg-base:       #FAF8F4;   /* pergamino cálido */
+--bg-surface:    #FFFFFF;
+--bg-subtle:     #F2EDE6;   /* secciones alternadas */
+--bg-emphasis:   #E8DDD2;   /* hover */
+
+/* Texto */
+--text-primary:  #1A1410;   /* casi negro cálido */
+--text-secondary:#6B5D52;   /* marrón medio */
+--text-muted:    #A89585;   /* gris cálido */
+--text-inverse:  #FAF8F4;
+
+/* Acento */
+--accent:        #C0392B;   /* rojo editorial */
+--accent-hover:  #A93226;
+--accent-subtle: #FDECEA;
+
+/* Secundario */
+--accent2:       #8B6914;   /* dorado oscuro para detalles */
+
+/* Estado */
+--success:       #27AE60;
+--warning:       #E67E22;
+--error:         #C0392B;
+--info:          #2980B9;
+
+/* Bordes */
+--border:        #DDD0C4;
+--border-strong: #B8A99A;
+```
+
+---
+
+## 3. Typography Rules
+
+```css
+/* Fuentes — la clave del sistema */
+--font-display: 'Playfair Display', 'Georgia', serif;  /* headings */
+--font-body:    'Source Serif 4', 'Georgia', serif;    /* body (serif también) */
+--font-ui:      'Inter', system-ui, sans-serif;        /* labels, nav, botones */
+--font-mono:    'JetBrains Mono', monospace;
+
+/* Escala */
+--text-xs:   12px / 1.4;   /* labels UI */
+--text-sm:   14px / 1.5;
+--text-base: 17px / 1.7;   /* cuerpo más generoso */
+--text-lg:   20px / 1.6;
+--text-xl:   24px / 1.4;
+--text-2xl:  30px / 1.3;
+--text-3xl:  38px / 1.15;
+--text-4xl:  48px / 1.05;
+
+/* Pesos display */
+--display-normal: 400;
+--display-italic: 400 italic;  /* uso frecuente de itálica en editorial */
+--display-bold:   700;
+```
+
+**Reglas específicas**:
+- H1: Playfair Display, 38–48px, weight 700, tracking -0.01em
+- H2: Playfair Display, 30px, weight 400 (elegante sin negrita)
+- Subtítulo / pullquote: Playfair Display italic, 20–24px
+- Body: Source Serif 4, 17px, line-height 1.7 (más espacio para lectura)
+- UI (botones, nav, labels): Inter, 13–14px
+
+---
+
+## 4. Component Stylings
+
+### Botones
+```css
+/* Primario — sin bordes redondeados, más recto */
+.btn-primary {
+  background: var(--accent);
+  color: white;
+  padding: 12px 28px;
+  border-radius: 2px;   /* casi cuadrado, editorial */
+  font-family: var(--font-ui);
+  font-weight: 500;
+  font-size: 13px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+/* Outline editorial */
+.btn-outline {
+  background: transparent;
+  border: 1.5px solid var(--text-primary);
+  color: var(--text-primary);
+  padding: 12px 28px;
+  border-radius: 2px;
+  font-family: var(--font-ui);
+  font-size: 13px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+```
+
+### Cards
+```css
+.card {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: 0;   /* cuadrado, editorial */
+  padding: 28px 32px;
+}
+
+/* Card con acento en borde izquierdo — solo para featured */
+.card-featured {
+  border-left: 3px solid var(--accent);
+  padding-left: 28px;
+}
+```
+
+### Divisores
+```css
+.divider {
+  border: none;
+  border-top: 1px solid var(--border);
+  margin: 32px 0;
+}
+
+/* Ornamental — para secciones principales */
+.divider-ornamental::before {
+  content: '✦';
+  display: block;
+  text-align: center;
+  color: var(--accent2);
+  margin-bottom: 8px;
+}
+```
+
+### Pullquotes
+```css
+.pullquote {
+  font-family: var(--font-display);
+  font-style: italic;
+  font-size: 22px;
+  line-height: 1.4;
+  color: var(--text-secondary);
+  border-left: 3px solid var(--accent);
+  padding-left: 20px;
+  margin: 32px 0;
+}
+```
+
+---
+
+## 5. Layout Principles
+
+- **Grid**: 12 columnas, gutter 24px, max-width 1100px (más angosto = más editorial)
+- **Columnas de contenido**: max 65–70 caracteres por línea (aprox 680px a 17px)
+- **Sidebar editorial**: a la derecha, 30% del ancho
+- **Espaciado**: múltiplos de 8px, generoso (secciones con 80–96px entre ellas)
+- **Drop cap**: primera letra grande en artículos principales
+
+---
+
+## 6. Depth & Elevation
+
+```css
+/* Casi sin sombras — la jerarquía viene de la tipografía y los bordes */
+--shadow-sm: 0 1px 4px rgba(26,20,16,0.08);
+--shadow-md: 0 4px 16px rgba(26,20,16,0.10);
+```
+
+Sin sombras de colores. Sin elevation artificial. El peso visual viene del tamaño y grosor tipográfico.
+
+---
+
+## 7. Do's and Don'ts
+
+**✅ Hacer:**
+- Mezclar tamaños tipográficos con contraste fuerte (48px headline + 17px body)
+- Usar itálica del display font para énfasis y citas
+- Espaciado generoso entre párrafos (margin-bottom: 24px en body)
+- Líneas divisoras delgadas entre secciones
+- Fechas, categorías y bylines en Inter 12px uppercase
+
+**❌ No hacer:**
+- Fondos de colores brillantes o saturados
+- Bordes muy redondeados (max 4px en botones, 0 en cards)
+- Gradientes (ninguno)
+- Iconos tipo emoji o ilustraciones de dibujos animados
+- Demasiados elementos en una pantalla (editorial es curado)
+- Tablas sin estilo cuidadoso de bordes
+- Imágenes sin ratio definido (usar aspect-ratio: 16/9 o 3/2)
+
+---
+
+## 8. Responsive Behavior
+
+```
+Desktop  (≥1024px): layout de revista 2–3 col, tipografía grande
+Tablet   (640–1023px): 1–2 col, tipografía reducida un nivel
+Mobile   (<640px): 1 col, heading 28px max, mayor padding lateral (20px)
+```
+
+---
+
+## 9. Agent Prompt Guide
+
+> Usa el sistema Warm Editorial: fondos pergamino (#FAF8F4), tipografía Playfair Display para headings (serif, con itálica), Source Serif 4 para cuerpo, Inter para UI. Acento rojo oscuro (#C0392B) solo en acciones. Tonos tierra (#6B5D52, #A89585). Bordes casi cuadrados (border-radius 2px en botones, 0 en cards). Sin gradientes. Sin bordes redondeados grandes. Espaciado generoso. El diseño se siente como una revista de calidad: curado, elegante, tipográficamente rico.

package/docs/AGENTES.md

@@ -1,6 +1,6 @@
 # Guía de Agentes Especializados
 
-SDD-ES incluye 11 agentes con roles bien definidos. Esta guía explica cuándo se activa cada uno.
+SDD-ES incluye 14 agentes con roles bien definidos. Esta guía explica cuándo se activa cada uno.
 
 ## Tabla rápida
 
@@ -17,6 +17,9 @@ SDD-ES incluye 11 agentes con roles bien definidos. Esta guía explica cuándo s
 | critico | opus | `/sdd.planificar`, `/sdd.analizar` | Riesgos y puntos ciegos |
 | seguridad | opus | Cambios sensibles automáticamente | Auditoría de vulnerabilidades |
 | documentador | sonnet | Bajo demanda (desactivado por defecto) | Docs útiles (no obvias) |
+| investigador | sonnet | Bajo demanda | Investigación técnica, benchmarks, comparativas |
+| product-designer | opus | `/sdd.diseñar` (fase de producto) | Pantallas P0/P1/P2, user flow, mvp_scope |
+| architecture-designer | sonnet | `/sdd.diseñar` (fase de stack) | Stack más simple viable, decisión técnica en lenguaje llano |
 
 ## Cuándo activar/desactivar agentes
 

package/docs/FABRICA.md

@@ -1,185 +1,234 @@
-# 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, 12 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 (12 Agentes Trabajando en Paralelo)
 
-Claude trabaja solo. Ves mensajes como:
+Una vez que el plan es definitivo, SDD-ES activa 12 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 12 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 |
+|-----------|-----------|-----------|
+| [EJEMPLO-E2E-REAL.md](EJEMPLO-E2E-REAL.md) | Todos | Diálogos exactos: qué escribes, qué responde Claude (paso a paso) |
+| [QUE-PASA-SI-FALLA.md](QUE-PASA-SI-FALLA.md) | No-técnicos | Respuestas: "¿y si cambio de idea?", "¿y si falla?", etc. |
+| [RESUMEN-EJECUTIVO-NO-TECNICOS.md](RESUMEN-EJECUTIVO-NO-TECNICOS.md) | Ejecutivos, managers | Qué cambió en v2.2, sin jerga |
+| [FLUJO.md](FLUJO.md) | Programadores | Comandos técnicos, workflows, pipes |
 
 ---
 
-## 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.