aicode-starter/
│
├── .context/                           Para: Documentacion de ingenieria de contexto (IA lee esto)
│   │
│   ├── README.md                       Para: Indice maestro del proyecto, punto de entrada
│   │
│   ├── idea/                           Para: FASE 1 - Constitucion del negocio
│   │   ├── README.md                   Para: Explicar Fase 1
│   │   ├── business-model.md           Para: Business Model Canvas (9 bloques)
│   │   ├── market-context.md           Para: Analisis de mercado y competencia
│   │   └── legacy-analysis.md          Para: Analisis de codigo existente (solo proyectos legacy)
│   │
│   ├── PRD/                            Para: FASE 2 - Product Requirements (vision de negocio)
│   │   ├── README.md                   Para: Explicar que es PRD
│   │   ├── executive-summary.md        Para: Problem statement + KPIs + target users
│   │   ├── user-personas.md            Para: 2-3 perfiles de usuarios detallados
│   │   ├── mvp-scope.md                Para: Epicas y user stories del MVP
│   │   └── user-journeys.md            Para: Flujos de usuario (happy path + edge cases)
│   │
│   ├── SRS/                            Para: FASE 2 - Software Requirements (vision tecnica)
│   │   ├── README.md                   Para: Explicar que es SRS
│   │   ├── functional-specs.md         Para: Requerimientos funcionales (FRs mapeados 1:1)
│   │   ├── non-functional-specs.md     Para: Performance, security, scalability
│   │   ├── architecture-specs.md       Para: C4 diagrams, ERD, tech stack
│   │   └── api-contracts.yaml          Para: OpenAPI 3.0 spec de todos los endpoints
│   │
│   ├── PBI/                            Para: FASES 4-6 - Product Backlog (tareas concretas)
│   │   ├── README.md                   Para: Explicar estructura de PBI
│   │   ├── epic-tree.md                Para: Vista high-level de todas las epicas
│   │   │
│   │   └── epics/                      Para: Contener todas las epicas del proyecto
│   │       │
│   │       └── EPIC-{PROYECTO}-{NUM}-{nombre}/  Para: Una epica (ej: EPIC-MYM-13-mentor-discovery)
│   │           │
│   │           ├── epic.md             Para: FASE 4 - Descripcion, scope, criteria
│   │           ├── feature-test-plan.md   Para: FASE 5 - Plan de pruebas a nivel feature
│   │           ├── feature-implementation-plan.md  Para: FASE 6 - Decisiones tecnicas de la epica
│   │           │
│   │           └── stories/            Para: Contener todas las stories de esta epica
│   │               │
│   │               └── STORY-{PROYECTO}-{NUM}-{nombre}/  Para: Una story (ej: STORY-MYM-14-view-mentors)
│   │                   │
│   │                   ├── story.md       Para: FASE 4 - User story + acceptance criteria
│   │                   ├── test-cases.md  Para: FASE 5 - 6+ test cases detallados
│   │                   └── implementation-plan.md  Para: FASE 6 - Plan tecnico step-by-step
│   │
│   └── guidelines/                     Para: FASES 7-14 - Reference material para la IA
│       ├── README.md                   Para: Explicar guidelines y su uso
│       │
│       ├── Workflow y Estandares:
│       ├── implementation-workflow.md  Para: Workflow paso a paso de implementacion
│       ├── code-standards.md           Para: DRY, naming, TypeScript strict
│       ├── error-handling.md           Para: NO hardcodear, error classes, logging
│       ├── context-loading.md          Para: Que archivos leer en cada fase
│       ├── mcp-usage-tips.md           Para: Cuando usar Supabase/Atlassian MCP
│       │
│       └── TAE/                        Para: FASE 12 - Test Automation Engineering
│           ├── README.md               Para: Explicar TAE y workflow de uso
│           ├── test-strategy.md        Para: Estrategia general de testing del proyecto
│           ├── kata-architecture.md    Para: Arquitectura KATA adaptada al proyecto
│           ├── automation-standards.md Para: Estandares de codigo para tests
│           └── ...
│
├── .prompts/                           Para: Prompts copy-paste para generar documentacion
│   │
│   ├── README.md                       Para: Instrucciones de como usar los prompts
│   │
│   ├── fase-1-constitution/            Para: Generar docs de negocio
│   │   ├── business-model.md           Para: Prompt de Business Model Canvas
│   │   └── market-context.md           Para: Prompt de analisis de mercado
│   │
│   ├── fase-2-architecture/            Para: Generar specs de producto y arquitectura
│   │   ├── prd-executive-summary.md    Para: Prompt de executive summary
│   │   ├── prd-user-personas.md        Para: Prompt de user personas
│   │   ├── prd-mvp-scope.md            Para: Prompt de epicas iniciales
│   │   ├── prd-user-journeys.md        Para: Prompt de user journeys
│   │   ├── srs-functional-specs.md     Para: Prompt de FRs
│   │   ├── srs-non-functional-specs.md Para: Prompt de NFRs
│   │   ├── srs-architecture-specs.md   Para: Prompt de arquitectura + C4
│   │   └── srs-api-contracts.md        Para: Prompt de OpenAPI spec
│   │
│   ├── fase-3-infrastructure/          Para: Setup tecnico base (una sola vez)
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── backend-setup.md            Para: DB schemas + API boilerplate
│   │   └── frontend-setup.md           Para: Design System + proyecto frontend
│   │
│   ├── fase-4-specification/           Para: Generar product backlog (PBI)
│   │   ├── pbi-product-backlog.md      Para: Setup MVP - epic-tree + epicas/stories (Jira-First)
│   │   └── pbi-add-feature.md          Para: Post-MVP - Analiza + crea features (3 niveles)
│   │
│   ├── fase-5-shift-left-testing/      Para: Generar docs de testing
│   │   ├── feature-test-plan.md        Para: Prompt de plan de pruebas (epica)
│   │   └── story-test-cases.md         Para: Prompt de test cases (story)
│   │
│   ├── fase-6-planning/                Para: Generar planes de implementacion
│   │   ├── feature-implementation-plan.md Para: Prompt de plan tecnico (epica)
│   │   └── story-implementation-plan.md   Para: Prompt de plan tecnico (story)
│   │
│   ├── fase-7-implementation/          Para: Guias de implementacion de codigo
│   │   ├── README.md                   Para: Guia de uso de prompts de implementacion
│   │   ├── implement-story.md          Para: Implementar story desde cero
│   │   ├── continue-implementation.md  Para: Retomar story pausada
│   │   ├── fix-issues.md               Para: Debuggear y corregir errores
│   │   └── unit-testing.md             Para: Agregar unit tests
│   │
│   ├── fase-8-code-review/             Para: Guias de code review estatico
│   │   ├── README.md                   Para: Guia de uso de prompts de review
│   │   ├── review-pr.md                Para: Review completo de codigo
│   │   └── setup-linting.md            Para: Configurar ESLint + Prettier
│   │
│   ├── fase-9-deployment-staging/      Para: Deploy a ambiente de pruebas
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── ci-cd-setup.md              Para: GitHub Actions workflow
│   │   ├── environment-config.md       Para: Configurar secrets por ambiente
│   │   └── deploy-to-staging.md        Para: Deploy automatizado
│   │
│   ├── fase-10-exploratory-testing/    Para: Testing manual rapido
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── smoke-test.md               Para: Validar deployment
│   │   ├── exploratory-test.md         Para: Exploracion profunda con Playwright MCP
│   │   └── bug-report.md               Para: Reportar bugs
│   │
│   ├── fase-11-test-documentation/     Para: Documentacion de tests en Jira
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── test-analysis.md            Para: Analizar candidatos para regression
│   │   ├── test-prioritization.md      Para: Priorizar tests
│   │   └── test-documentation.md       Para: Crear Test issues en Jira
│   │
│   ├── fase-12-test-automation/        Para: Automation con KATA framework
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── kata-framework-setup.md     Para: Setup inicial KATA
│   │   ├── automation-e2e-test.md      Para: Implementar tests E2E
│   │   └── automation-integration-test.md Para: Implementar tests API
│   │
│   ├── fase-13-production-deployment/  Para: Deploy a produccion
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── pre-deploy-checklist.md     Para: Validaciones pre-deploy
│   │   ├── deploy-to-production.md     Para: Estrategia de deploy
│   │   └── rollback-plan.md            Para: Plan de contingencia
│   │
│   ├── fase-14-shift-right-testing/    Para: Monitoring y observabilidad
│   │   ├── README.md                   Para: Guia de la fase
│   │   ├── monitoring-setup.md         Para: Configurar Sentry/logs
│   │   ├── smoke-tests.md              Para: Tests post-deploy
│   │   └── incident-response.md        Para: Playbook de incidentes
│   │
│   ├── git-flow.md                     Para: Estrategia de branching
│   ├── git-conflict-fix.md             Para: Resolver conflictos de merge
│   ├── us-dev-workflow.md              Para: Workflow completo de desarrollo (Fases 6-9)
│   └── us-qa-workflow.md               Para: Workflow completo de QA (Fases 10-12)
│
└── docs/                               Para: Documentacion maestra del sistema
    ├── README.md                       Para: Indice de toda la documentacion
    │
    ├── Arquitectura y Blueprint
    │   ├── ai-driven-software-project-blueprint.md  Para: Metodologia de 14 fases
    │   └── kata-test-architecture.md   Para: Framework de testing KATA
    │
    └── MCP Configuration (Model Context Protocol)
        ├── mcp-config-general.md       Para: Conceptos fundamentales de MCP
        ├── mcp-config-claudecode.md    Para: Configuracion Claude Code
        ├── mcp-config-geminicli.md     Para: Configuracion Gemini CLI
        ├── mcp-config-copilotcli.md    Para: Configuracion GitHub Copilot CLI
        ├── mcp-config-vscode.md        Para: Configuracion VS Code + Copilot
        └── mcp-builder-strategy.md     Para: Optimizacion de tokens (session-based)

Input: Idea de negocio
Usar: .prompts/fase-1-constitution/
Output: .context/idea/ (2-3 archivos)
Quien: Founder, Cliente, Product Owner

Input: .context/idea/
Usar: .prompts/fase-2-architecture/
Output:
  - .context/PRD/ (4 archivos: executive-summary, user-personas, mvp-scope, user-journeys)
  - .context/SRS/ (4 archivos: functional-specs, non-functional-specs, architecture-specs, api-contracts)
Quien: Solution Architect, Product Manager, Business Analyst

Input: .context/PRD/ + .context/SRS/
Usar: .prompts/fase-3-infrastructure/

Ejecutar en orden:
1. backend-setup.md       → DB schemas + API + tipos TypeScript
2. frontend-setup.md      → Design System + proyecto frontend

Output: Proyecto base funcional con backend + frontend integrados
Quien: DevOps, Backend Dev, Frontend Dev

Por que este orden:
- Backend define schemas → genera tipos TypeScript
- Frontend consume esos tipos → zero type errors

Input (MVP): .context/PRD/ + .context/SRS/
Input (Post-MVP): Descripcion de feature/idea
Usar:
  - .prompts/fase-4-specification/pbi-product-backlog.md (setup MVP)
  - .prompts/fase-4-specification/pbi-add-feature.md (agregar features)

Flujo Jira-First:
  1. Crea epica/story en Jira (MCP) → Obtiene ID real
  2. Crea carpeta local con ID real (ej: EPIC-MYM-13-nombre/)
  3. Crea archivos .md locales

Output:
  - .context/PBI/epic-tree.md
  - .context/PBI/epics/EPIC-{PROYECTO}-{NUM}-{nombre}/epic.md
  - .context/PBI/epics/.../stories/STORY-{PROYECTO}-{NUM}-{nombre}/story.md

Beneficio: Nomenclatura correcta desde el inicio (IDs reales de Jira)
Quien: Product Owner, Product Manager

Input: .context/PBI/ (epicas y stories especificas)
Usar: .prompts/fase-5-shift-left-testing/
Output:
  - .context/PBI/epics/EPIC-XXX/feature-test-plan.md
  - .context/PBI/epics/EPIC-XXX/stories/STORY-XXX/test-cases.md
Quien: QA Engineer, Test Lead

Input: .context/PBI/ + .context/SRS/
Usar: .prompts/fase-6-planning/
Output:
  - .context/PBI/epics/EPIC-XXX/feature-implementation-plan.md
  - .context/PBI/epics/EPIC-XXX/stories/STORY-XXX/implementation-plan.md
Quien: Tech Lead, Senior Developer

Input: .context/PBI/epics/EPIC-XXX/stories/STORY-XXX/implementation-plan.md
Leer: .context/guidelines/ (TODOS los archivos)
Usar: .prompts/fase-7-implementation/

Flujo:
1. implement-story.md     → Implementar funcionalidad
2. unit-testing.md        → Agregar unit tests (si aplica)

Output: Codigo funcional implementado (src/, componentes, API, DB) + unit tests
Quien: Developer + AI Assistant
Nota: Solo funcionalidad + unit tests - NO incluye integration/E2E tests (esos van en Fase 12)

Input: Codigo implementado (Fase 7)
Leer: .context/guidelines/code-standards.md
Usar: .prompts/fase-8-code-review/
Output: Reporte de review (APPROVE / CHANGES REQUESTED)
Quien: Tech Lead, Senior Developer
Nota: Analisis estatico - NO revisa tests (tests van en Fase 12)

Input: Codigo aprobado (Fase 8)
Usar: .prompts/fase-9-deployment-staging/

CI/CD ejecuta automaticamente:
1. Linting
2. Unit tests
3. Build
4. Deploy to Vercel Staging

Output: URL de staging disponible
Quien: DevOps (automatizado)

Input: URL de staging
Usar: .prompts/fase-10-exploratory-testing/

Flujo:
1. smoke-test.md          → Validar deployment (5 min)
2. exploratory-test.md    → Exploracion profunda con Playwright MCP
3. bug-report.md          → Reportar bugs

Output: Feedback manual + bugs encontrados
Quien: QA Engineer

Por que manual antes que automatizado:
- Feedback rapido (minutos vs horas)
- Encuentra bugs de UX que tests automatizados no ven
- Solo automatizas lo ya validado manualmente

Input: Exploratory findings (Fase 10)
Usar: .prompts/fase-11-test-documentation/

Flujo:
1. test-analysis.md       → Analizar candidatos para regression
2. test-prioritization.md → Priorizar tests
3. test-documentation.md  → Crear Test issues en Jira

Output: Tests documentados en Jira con trazabilidad
Quien: QA Engineer

Input: Tests documentados (Fase 11)
Usar: .prompts/fase-12-test-automation/

Arquitectura: KATA Framework

Flujo:
1. kata-framework-setup.md         → Setup inicial (primera vez)
2. automation-integration-test.md  → Implementar tests API
3. automation-e2e-test.md          → Implementar tests E2E

Output: Integration + E2E tests funcionando en CI/CD
Quien: QA Automation Engineer, SDET
Nota: Solo automatiza lo ya validado en Fase 10

Tipos de tests:
- Integration tests (API)
- E2E tests (UI con Playwright)
- NO unit tests (esos van en Fase 7)

Input: Tests automation pasando (Fase 12)
Usar: .prompts/fase-13-production-deployment/

Flujo:
1. pre-deploy-checklist.md   → Validaciones pre-deploy
2. deploy-to-production.md   → Deploy estrategico
3. rollback-plan.md          → Solo si hay problemas

Output: Codigo en produccion
Quien: DevOps

Input: Produccion activa
Usar: .prompts/fase-14-shift-right-testing/

Componentes:
- Monitoring (Sentry, logs)
- Smoke tests post-deploy
- Incident response

Output: Observabilidad activa
Quien: SRE, DevOps

.context/PBI/epics/EPIC-MYM-13-mentor-discovery/stories/STORY-MYM-14-view-mentors/
├── story.md                    (Fase 4: Que hacer)
├── test-cases.md               (Fase 5: Como probar)
└── implementation-plan.md      (Fase 6: Como implementar)