Saltar a contenido

Flujo: Onboarding de Proyecto Legacy a SDD

Pipeline que toma un proyecto legacy sin documentacion y lo prepara para operar con el flujo Spec-Driven Development. SDD Legacy escanea el codebase, extrae features y reglas de negocio enterradas en el codigo, genera Feature Specs y milestones compatibles con ATL Inteliside, y entrega el proyecto listo para recibir features nuevas (via SDD-Wizards) e implementaciones (via ATL). El PM lidera el onboarding mientras el Dev puede empezar a implementar desde el primer handoff per-feature.

Resumen

El pipeline tiene 3 fases con un orden canonico estricto: audit -> conventions -> [spec -> rules -> handoff] x N -> baseline -> onboard. En la Fase 1 (Setup), el PM audita el proyecto y formaliza convenciones. En la Fase 2 (Per-feature), el PM extrae Feature Specs y reglas de negocio feature por feature, haciendo handoff al Dev tras cada ciclo — el Dev puede implementar en paralelo con ATL. En la Fase 3 (Cierre), el PM genera el baseline de deuda tecnica y completa el onboarding. Al terminar, el proyecto queda SDD-ready: CLAUDE.md configurado, labels creados, Engram inicializado, y milestones listos para ATL.

Etapas

Fase 1 — Setup (una sola vez)

Etapa 1.1 — Auditoria del proyecto

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-audit-wizard
  • Modelo: opus
  • Que produce:
  • Audit Report con health score por area (code quality, testing, dependencies, architecture, documentation)
  • Deteccion de stack y deuda tecnica
  • Bootstrap de ATL en CLAUDE.md
  • Rama sdd/setup con push a GitHub
  • GitHub Project vinculado (creado o detectado)
  • Donde lo deja:
  • Engram: legacy/audit, legacy/stack, legacy/health-score, project/github-context
  • GitHub: rama sdd/setup, proyecto vinculado
  • Quien lo consume: legacy-conventions-wizard, legacy-spec-extractor, legacy-baseline-wizard

Etapa 1.2 — Formalizacion de convenciones

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-conventions-wizard
  • Modelo: sonnet
  • Que produce:
  • Archivos .claude/rules/*.md con convenciones detectadas del codigo (naming, estructura, testing, imports, etc.)
  • Commit en rama sdd/setup
  • Donde lo deja:
  • Engram: legacy/conventions
  • Filesystem: .claude/rules/ en el proyecto
  • Quien lo consume: legacy-spec-extractor, legacy-onboard-wizard
  • Accion post-etapa: notificar al Dev para que haga pull de la rama sdd/setup

Fase 2 — Extraccion per-feature (repetir N veces)

Esta fase se ejecuta en ciclos. Cada ciclo procesa una feature y produce un handoff que el Dev puede tomar inmediatamente con ATL. El PM no necesita esperar a que el Dev termine para continuar con la siguiente feature.

Etapa 2.1 — Extraccion de Feature Spec

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-spec-extractor [feature-name] (per-feature recomendado, bulk disponible)
  • Modelo: opus
  • Que produce:
  • Feature Spec en formato identico a SDD-Wizards (User Stories, ACs, BRs, Data Model, API)
  • Milestone feat-[nombre] en GitHub con Feature Spec como body
  • Issue con labels feature-spec + atl-ready
  • PRD retroactivo (si es la primera feature, genera legacy/prd con vision del proyecto)
  • Deteccion de issues preexistentes en el repo
  • Donde lo deja:
  • Engram: legacy/features/{feature-name}, legacy/features-index, legacy/prd, legacy/preexisting-issues
  • GitHub: milestone + issue en GitHub Project
  • Quien lo consume: legacy-rules-extractor, legacy-handoff, ATL (via milestone)

Etapa 2.2 — Extraccion de reglas de negocio

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-rules-extractor [domain] (per-domain recomendado, bulk disponible)
  • Modelo: opus
  • Que produce:
  • Reglas de negocio extraidas del codigo con trazabilidad (archivo:linea)
  • Test cases Given/When/Then derivados de las reglas
  • Donde lo deja:
  • Engram: legacy/rules/{domain}, legacy/test-cases/{domain}, legacy/rules-index
  • Quien lo consume: legacy-baseline-wizard, legacy-onboard-wizard

Etapa 2.3 — Handoff per-feature

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-handoff [feature-name]
  • Modelo: sonnet
  • Que produce:
  • Validacion de artefactos de la feature (spec + rules completos)
  • Commit y push de artefactos al repo
  • Label atl-ready en el issue de GitHub
  • Donde lo deja:
  • Engram: legacy/handoff/{feature}
  • GitHub: issue con label atl-ready, commit en repo
  • Quien lo consume: Dev con ATL Inteliside

El Dev puede empezar ahora: /atl-inteliside:orchestrador feat-[feature]

Fase 3 — Cierre (una sola vez, despues de todas las features)

Etapa 3.1 — Baseline de deuda tecnica

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-baseline-wizard
  • Modelo: sonnet
  • Que produce:
  • Plan de accion priorizado para SDD-readiness
  • Milestone baseline-sdd en GitHub con issues ATL-compatible
  • Priorizacion basada en health score del audit
  • Donde lo deja:
  • Engram: legacy/baseline
  • GitHub: milestone baseline-sdd con issues
  • Quien lo consume: legacy-onboard-wizard, Dev (puede implementar baseline con ATL)

Etapa 3.2 — Onboarding final

  • Quien: PM
  • Plugin: sdd-legacy
  • Skill: /sdd-legacy:legacy-onboard-wizard
  • Modelo: sonnet
  • Que produce:
  • CLAUDE.md completo y configurado con datos del proyecto, stack, Engram y ATL
  • Labels faltantes creados en GitHub
  • Engram inicializado con project/config (compatible con ATL sdd-init)
  • Validacion final de que todo esta en orden
  • Donde lo deja:
  • Engram: legacy/onboard-status, project/config
  • Filesystem: CLAUDE.md definitivo
  • GitHub: labels completos
  • Quien lo consume: SDD-Wizards (features nuevas), ATL Inteliside (implementacion)

Diagrama del flujo

PM (SDD Legacy)                              Dev (ATL Inteliside)
 |                                               |
 | FASE 1 — SETUP                                |
 |                                               |
 | 1.1 /legacy-audit-wizard                      |
 |   [codebase -> audit report]                  |
 |   -> Engram: legacy/audit, legacy/stack       |
 |   -> GitHub: rama sdd/setup                   |
 |                                               |
 | 1.2 /legacy-conventions-wizard                |
 |   [codigo -> .claude/rules/]                  |
 |   -> commit en sdd/setup                      |
 |   ------notificar: "haz pull"-------->        |
 |                                               |
 | FASE 2 — PER-FEATURE (x N)                   |
 |                                               |
 | 2.1 /legacy-spec-extractor feat-A             |
 |   [codigo -> Feature Spec]                    |
 |   -> GitHub: milestone feat-A                 |
 |                                               |
 | 2.2 /legacy-rules-extractor domain-A          |
 |   [codigo -> reglas + test cases]             |
 |                                               |
 | 2.3 /legacy-handoff feat-A                    |
 |   [validar + commit + push]                   |
 |   -> GitHub: label atl-ready                  |
 |   ------handoff per-feature-------->          |
 |                                      /orchestrador feat-A
 | 2.1 /legacy-spec-extractor feat-B    [milestone -> codigo]
 |   ...                                Ingesta -> Verify
 | 2.2 /legacy-rules-extractor          -> Archivo
 | 2.3 /legacy-handoff feat-B                    |
 |   ------handoff per-feature-------->          |
 |                                      /orchestrador feat-B
 |   ... (repetir por cada feature)     ...      |
 |                                               |
 | FASE 3 — CIERRE                               |
 |                                               |
 | 3.1 /legacy-baseline-wizard                   |
 |   [deuda tecnica -> plan priorizado]          |
 |   -> GitHub: milestone baseline-sdd           |
 |                                               |
 | 3.2 /legacy-onboard-wizard                    |
 |   [CLAUDE.md + labels + Engram]               |
 |   -> Proyecto SDD-ready                       |
 |                                               |
 | TRANSICION                                    |
 |                                               |
 | Features nuevas:                     Baseline:
 | /sdd-wizards:feature-spec-wizard     /orchestrador baseline-sdd
 | Implementacion:                               |
 | /atl-inteliside:orchestrador feat-X           |

Handoffs entre equipos

De A Artefacto Medio
PM (audit-wizard) Dev Rama sdd/setup con audit + convenciones GitHub (rama sdd/setup)
PM (legacy-handoff) Dev (ATL) Feature Spec validada GitHub (milestone feat-* con label atl-ready) + Engram (legacy/handoff/{feature})
PM (baseline-wizard) Dev (ATL) Plan de deuda tecnica GitHub (milestone baseline-sdd)
PM (onboard-wizard) Equipo completo Proyecto SDD-ready Filesystem (CLAUDE.md) + Engram (project/config) + GitHub (labels)
Dev (ATL sdd-archive) Equipo futuro Conocimiento de implementacion Engram (team/decisions/, team/patterns/, team/completed/)

Comandos por etapa

Etapa Comando Quien lo ejecuta
Auditoria /sdd-legacy:legacy-audit-wizard PM
Convenciones /sdd-legacy:legacy-conventions-wizard PM
Extraccion de spec /sdd-legacy:legacy-spec-extractor [feature-name] PM
Extraccion de reglas /sdd-legacy:legacy-rules-extractor [domain] PM
Handoff per-feature /sdd-legacy:legacy-handoff [feature-name] PM
Baseline /sdd-legacy:legacy-baseline-wizard PM
Onboarding /sdd-legacy:legacy-onboard-wizard PM
Implementar feature /atl-inteliside:orchestrador feat-[nombre] Dev
Implementar baseline /atl-inteliside:orchestrador baseline-sdd Dev
Features nuevas (post-onboard) /sdd-wizards:feature-spec-wizard [nombre] PM

Notas operativas

  • Una conversacion por wizard: cada skill debe ejecutarse en sesion aislada para evitar overflow de contexto.
  • Orden canonico obligatorio: audit -> conventions -> [spec -> rules -> handoff] x N -> baseline -> onboard. No se puede saltar ni reordenar.
  • Per-feature es el modo recomendado: aunque spec-extractor y rules-extractor soportan modo bulk, per-feature permite handoff incremental al Dev.
  • Paralelismo PM/Dev: el Dev puede implementar con ATL desde el primer handoff sin esperar a que el PM termine todas las features.
  • SDD Legacy no modifica codigo funcional: solo lee, analiza y documenta. Las escrituras son a CLAUDE.md, .claude/rules/ y artefactos de documentacion.
  • GitHub es el canal de entrega: los milestones con label atl-ready son identicos a los de SDD-Wizards — ATL no distingue el origen.

Flujo Onboarding Legacy — Marketplace Inteliside