Flujo: De Idea a Feature Implementada¶

Pipeline end-to-end que transforma una idea de producto en codigo verificado y desplegable. Involucra tres roles (PM, Designer, Dev) y tres plugins (SDD-Wizards, UX Studio, ATL Inteliside) coordinados via Engram como memoria compartida y GitHub Projects como canal de entrega. Cada rol trabaja en conversaciones aisladas, produciendo artefactos con schemas fijos que el siguiente rol consume de forma determinista.

Resumen¶

El PM levanta requerimientos con SDD-Wizards: primero crea un PRD profesional con el prd-wizard (producto, usuarios, stories, arquitectura, stack), y luego detalla cada feature con el feature-spec-wizard (User Stories, Acceptance Criteria, Business Rules, Data Model, API Spec). El Designer investiga tendencias y genera la direccion visual con UX Studio: investiga competencia, entrevista al PM sobre preferencias de diseno, genera 3 opciones por componente en Pencil, y entrega un Design Spec con tokens, motion, interactions y responsive. El Dev toma el milestone de GitHub y ejecuta la implementacion con ATL Inteliside: genera spec tecnica, descompone en tasks, escribe tests primero (TDD), implementa, verifica contra ACs del PM, y cierra automaticamente el milestone.

Etapas¶

Etapa 1 — PRD (PM)¶

Quien: Product Manager
Plugin: sdd-wizards
Skill: /sdd-wizards:prd-wizard [nombre-producto]
Que produce:
PRD-[nombre].md — documento de requerimientos completo
Repositorio en GitHub (si no existe)
GitHub Project vinculado al repo
CLAUDE.md con configuracion ATL
.claude/rules/ con convenciones del stack
9 labels ATL en el repo
Donde lo deja:
GitHub: repo, project, PRD como issue con label prd
Engram: project/prd, project/stack, project/github-context
Quien lo consume: Designer (UX Studio) y PM en la siguiente etapa

Etapa 2 — Feature Spec (PM)¶

Quien: Product Manager
Plugin: sdd-wizards
Skill: /sdd-wizards:feature-spec-wizard [nombre-feature] (una conversacion por feature)
Que produce:
feat-[nombre].md — Feature Spec con User Stories, ACs, BRs, Data Model, API Spec
Milestone feat-[nombre] en GitHub con contenido completo
Issue vinculado con labels feature-spec + atl-ready
Donde lo deja:
GitHub: milestone + issue en GitHub Project
Engram: project/features/{feature-name}, project/features-index, project/handoff/{feature}
Quien lo consume: Designer (UX Studio) y Dev (ATL Inteliside)

Etapa 3 — Investigacion y Diseno UI/UX (Designer)¶

Quien: Designer (PM participa en fases interactivas)
Plugin: ux-studio
Skills: /ux-studio:ux-discovery + /ux-studio:ux-orchestrator
Que produce (pipeline de 8 fases):
Design Research Report (competencia, tendencias, motion patterns)
UX Brief (preferencias del PM: marca, mood, plataforma, accesibilidad)
Design Direction (visual, motion, interaction, responsive)
Design Prompts (3 opciones A/B/C por componente)
Disenos en Pencil (.pen) con tokens del Design Direction
Design Review (validacion contra 6 dimensiones de calidad)
PM Review (PM elige opciones por componente)
Design Spec final con tokens, component mapping, motion, interactions, responsive
Donde lo deja:
Engram: ux-studio/research-report, ux-studio/ux-brief, ux-studio/design-direction, ux-studio/design-prompts, ux-studio/pen-files, ux-studio/design-review, ux-studio/pm-selections, ux-studio/design-spec
GitHub: seccion ## Design References en el issue del Feature Spec, label design-ready
Quien lo consume: Dev (ATL Inteliside)

Etapa 4 — Implementacion (Dev)¶

Quien: Desarrollador
Plugin: atl-inteliside
Skill: /atl-inteliside:orchestrador feat-[nombre]
Que produce (pipeline DAG de 10 fases):
Ingesta del Feature Spec desde GitHub milestone
Deteccion de stack e inicializacion de Engram
Exploracion del codebase (que existe, que construir, conflictos)
Propuesta formal (intent, alcance, enfoque, rollback)
Spec tecnica RFC 2119 + Diseno de arquitectura (en paralelo)
Tasks atomicas por fases (Foundation, Core, Integration, UI, Testing) como issues en GitHub
Tests TDD antes del codigo (Given/When/Then)
Implementacion (RED -> GREEN -> REFACTOR por fase)
Verificacion: ACs del PM + RFs tecnicos + tests reales
Archivo: cierre de issues/milestone, promocion de conocimiento a Engram
Donde lo deja:
GitHub: issues cerrados, milestone cerrado, label atl:done
Engram (equipo): team/decisions/, team/patterns/, team/bugs/, team/completed/{feature}
Engram (pipeline): limpiado al archivar
Quien lo consume: el equipo en futuras features (via Engram)

Diagrama del flujo¶

PM                          Designer                    Dev
 |                              |                        |
 | 1. /prd-wizard               |                        |
 |   [idea -> PRD]              |                        |
 |   -> GitHub: repo, project   |                        |
 |   -> Engram: project/prd     |                        |
 |                              |                        |
 | 2. /feature-spec-wizard      |                        |
 |   [PRD -> Feature Spec]      |                        |
 |   -> GitHub: milestone       |                        |
 |   -> Engram: project/features|                        |
 |   ------handoff-------->     |                        |
 |                              |                        |
 |                 3. /ux-discovery                       |
 |   <---entrevista--->         |                        |
 |                    /ux-orchestrator                    |
 |                    [Research -> Design ->              |
 |   <---PM Review--->  Handoff]                         |
 |                              |                        |
 |                    -> GitHub: design-ready             |
 |                    -> Engram: ux-studio/*              |
 |                              |---handoff-------->     |
 |                              |                        |
 |                              |  4. /orchestrador      |
 |                              |  [milestone -> code]   |
 |                              |  Ingesta               |
 |                              |  Exploracion           |
 |   <---aprobar propuesta---   |  Propuesta             |
 |                              |  Spec + Design         |
 |                              |  Tasks -> GitHub       |
 |                              |  Tests (TDD)           |
 |                              |  Implementacion        |
 |                              |  Verificacion          |
 |                              |  Archivo               |
 |                              |  -> GitHub: cerrado    |
 |                              |  -> Engram: team/*     |

Handoffs entre equipos¶

De	A	Artefacto	Medio
PM (prd-wizard)	PM (feature-spec-wizard)	PRD completo	Engram (`project/prd`) + GitHub (issue con label `prd`)
PM (feature-spec-wizard)	Designer (ux-studio)	Feature Spec	GitHub (milestone `feat-*`) + Engram (`project/features/{name}`)
PM (feature-spec-wizard)	Dev (ATL)	Feature Spec	GitHub (milestone `feat-*` con label `atl-ready`) + Engram (`project/handoff/{feature}`)
Designer (ux-orchestrator)	Dev (ATL)	Design Spec	GitHub (issue con label `design-ready`) + Engram (`ux-studio/design-spec`)
Dev (sdd-archive)	Equipo futuro	Conocimiento	Engram (`team/decisions/`, `team/patterns/`, `team/bugs/`, `team/completed/`)

Comandos por etapa¶

Etapa	Comando	Quien lo ejecuta
PRD	`/sdd-wizards:prd-wizard [nombre-producto]`	PM
Feature Spec	`/sdd-wizards:feature-spec-wizard [nombre-feature]`	PM
Stack tecnico	`/sdd-wizards:tech-stack-selector` (invocado automaticamente durante PRD)	PM (indirecto)
Discovery UX	`/ux-studio:ux-discovery`	Designer + PM
Pipeline UX	`/ux-studio:ux-orchestrator`	Designer
Implementacion	`/atl-inteliside:orchestrador feat-[nombre]`	Dev
Continuar DAG	`/sdd-continue`	Dev
Implementar fase	`/sdd-apply [Foundation\\|Core\\|Integration\\|UI\\|Testing]`	Dev
Verificar	`/sdd-verify`	Dev
Archivar	`/sdd-archive`	Dev

Notas operativas¶

Una conversacion por skill: no mezclar PRD y Feature Spec en la misma sesion.
Una conversacion por feature: cada Feature Spec se detalla en conversacion dedicada.
UX Studio es opcional: si no hay Designer, el Dev toma el milestone directo de GitHub y ATL implementa sin Design Spec.
Engram es el pegamento: todos los plugins escriben al mismo engram_project. Sin Engram, los handoffs se hacen manualmente via GitHub.
GitHub es el canal de entrega: milestones con labels atl-ready / design-ready son las senales de handoff formales.

Flujo PM a Dev — Marketplace Inteliside