Antes de empezar

BCP · NTT DATA · Train-the-Trainers IA · Día 2

De los hallazgos
a capacidades reutilizables.

Trabaja sobre el flujo de login de ReqFlow. Convierte los hallazgos del Día 1 en Skills, historias trazables y un backlog listo para el Día 3.

09:30 a 18:003 sesiones + evaluación W1Tu workspace del Día 1

Comenzar S1 →
Workspace y entrada del dia
  • Trabajas en tu reqflow-workspace/ del Dia 1, con tus tres repos propios: workshop-auth-backend, workshop-login-frontend y workshop-requirements-api. Clona este laboratorio al lado del workspace, no dentro, y abre VS Code sobre reqflow-workspace/.
  • Del Dia 1 necesitas HALLAZGOS.md (filas "Pendiente" con Id H-xx), prompts/, docs/ENDPOINTS.md y docs/TESTING.md.
  • Verifica la entrada desde la carpeta del laboratorio (al menos 1 repo en [OK]): python tools/check_handoff.py --day 1 ../reqflow-workspace
  • Si el chequeo falla, parte de la rama checkpoint/day1 que entrega el instructor.
Prerrequisitos
  • GitHub CLI, Copilot y acceso concedido.
  • Python, Node.js y Maven instalados.
  • Docker disponible si el issue lo requiere.
09:3011:30
Laboratorio S1

Skill básico

Crear un Skill reutilizable que convierta una feature request en un paquete minimo trazable. Usando: Metadata, I/O y constraints.

2 h
Materiales
  • Skill: feature-intake-spec-checklist, version 0.1.0
  • Ruta estandar del repositorio: .github/skills/
  • reqflow-workspace/ del Dia 1 abierto en VS Code, con Copilot Chat. S1 se trabaja dentro de workshop-auth-backend/: las rutas relativas parten de ahi.
  • Git y un IDE con soporte Markdown

Usarlo antes de crear tareas de implementacion o abrir un PR significativo.

Pasos
01
Crear estructura del Skill
Tiempo estimado: 5 minutos. Crea el Skill en la ruta estandar .github/skills/ de workshop-auth-backend.
mkdir -p .github/skills/feature-intake-spec-checklist/examples
touch .github/skills/feature-intake-spec-checklist/SKILL.md
touch .github/skills/feature-intake-spec-checklist/examples/input.sample.md
touch .github/skills/feature-intake-spec-checklist/examples/output.sample.md
Salida esperada: tres archivos existen bajo .github/skills/feature-intake-spec-checklist/ - SKILL.md, examples/input.sample.md, examples/output.sample.md - sin que su contenido este completo aun.
02
Completar el contrato
Tiempo estimado: 30-40 minutos. Abre SKILL.md, elimina su contenido y pega la plantilla; reemplaza los [EDITAR] o marca "Pendiente de confirmar".
---
name: feature-intake-spec-checklist
description: Estandariza la definición de funcionalidades antes de la implementación generando un paquete mínimo trazable que cubra alcance, decisiones, riesgos, criterios de aceptación y planes de validación.
---

# Skill: Feature Intake -> Spec Checklist

## 1) Metadata
- **Skill ID:** feature-intake-spec-checklist
- **Version:** 0.1.0
- **Purpose:** Estandarizar la definición de funcionalidades antes de la implementación generando un paquete mínimo trazable que cubra alcance, decisiones, riesgos, aceptación y validación.
- **Audience (roles):** Chapter/PO, Tech Lead, Backend, Frontend, QA, Cyber
- **When to use:** Antes de crear tareas de implementación o abrir un PR significativo.
- **When NOT to use:** Incidentes P1 de producción, cambios triviales como typos o tareas sin impacto funcional.
- **Sensitive inputs:** No incluyas datos reales de clientes, credenciales, secretos, tokens ni URLs internas no autorizadas.
- **Expected output:** Markdown estructurado mediante la sección Output a continuación.

## 2) Inputs
Proporciona la información en este formato:

- **Business context (brief):**
- **Feature request / user story:**
- **Expected impact (metric or outcome):**
- **Scope (in/out):**
- **Known technical constraints:** (stack, standards, performance, availability)
- **Known risks:** (security, compliance, stability)
- **Dependencies:** (services, teams, data)
- **Team Definition of Done (DoD):** (if available)

## 3) Output
Devuelve **solo** un documento Markdown con estas secciones y bullets:

1. **Summary**
2. **Scope**
    - Dentro del alcance
    - Fuera del alcance
3. **Supuestos**
4. **Decisiones técnicas por tomar (pendientes o resueltas)**
5. **Riesgos y mitigaciones**
6. **Criterios de aceptación (medibles)**
7. **Plan de validación**
    - Pruebas unitarias
    - Pruebas funcionales
    - Seguridad (comprobaciones mínimas)
    - Evidencia requerida (qué adjuntar)
8. **Tareas sugeridas por rol**
    - Chapter/PO
    - Tech Lead
    - Backend
    - Frontend
    - QA
    - Cyber
9. **Preguntas abiertas**

## 4) Constraints
- No inventes requisitos: si falta información, inclúyela bajo **Preguntas abiertas**.
- No propongas herramientas fuera del stack permitido.
- No incluyas datos sensibles ni secretos.
- Los criterios de aceptación deben ser verificables; no escribas “mejorar el rendimiento” sin una métrica.
- El plan de validación debe incluir al menos un elemento de evidencia concreto, como salida de pruebas, un checklist o un archivo actualizado.
- Mantén la salida en un máximo de 1-2 páginas para que siga siendo usable.

## 5) Validation Rules
La salida es válida si:
- Incluye todas las secciones definidas en Output.
- Tiene al menos 3 criterios de aceptación medibles.
- Tiene al menos 3 tareas para cada rol central: Tech Lead, Backend y QA, o explica por qué un rol no aplica.
- Incluye al menos 2 riesgos con mitigaciones.
- No contiene datos sensibles ni secretos.
- No contiene supuestos no declarados.

## 6) Evidence
Adjunta o referencia estos elementos en el PR o entrega:
- `SKILL.md` versionado.
- `examples/input.sample.md`.
- `examples/output.sample.md`.
- Tag de versión para el Skill, como `skill-feature-intake-v0.1.0`.
Criterio de salida: otro rol debe poder leer el archivo y saber que activa el Skill, que informacion recibe, que devuelve, que limites respeta y como se valida.
03
Crear entrada
Tiempo estimado: 5-10 minutos. Pega el caso de ejemplo en examples/input.sample.md; puedes adaptar contexto, impacto o dependencias, conservando los ocho encabezados.
## Business context (brief)
Reduce complaints caused by duplicate transfers.

## Feature request / user story
As a user, I want to confirm a transfer before sending it
so that I can avoid duplicates.

## Expected impact
Reduce duplicate-transfer complaints by 20% in one month.

## Scope (in/out)
In: pre-send confirmation, summary message, data validation.
Out: infrastructure changes and a complete UI redesign.

## Known technical constraints
Existing REST API, web frontend, standardized logging.

## Known risks
Sensitive data exposure in logs; amount-validation errors.

## Dependencies
Accounts service and transfers service.

## Team Definition of Done (DoD)
Unit tests, brief documentation, and reviewed PR.
Criterio de salida: la entrada es suficientemente concreta para generar una especificacion sin inventar requisitos; lo no confirmado queda como pregunta abierta.
04
Crear salida
Tiempo estimado: 10-15 minutos. Genera examples/output.sample.md a partir de la entrada; puedes cambiar decisiones, riesgos o tareas pero no elimines secciones.
# Feature Intake -> Spec Checklist

## 1. Summary
Add a pre-send transfer confirmation with a concise summary
and validation of transfer data. Target: 20% reduction in
duplicate-transfer complaints in one month.

## 6. Acceptance criteria (measurable)
- 95%+ of valid attempts show confirmation before submission.
- Invalid data blocks submission with a validation message.
- Duplicate complaints drop 20% within one month.
- No sensitive values appear in confirmation event logs.

## 9. Open questions
- What baseline measures the 20% reduction?
- Which API version owns the confirmation contract?
Criterio de salida: documento Markdown de 1-2 paginas, accionable, sin decisiones no sustentadas por la entrada o una decision humana.
05
Demostrar y versionar el Skill
Tiempo estimado: 15-20 minutos. Demuestra que el Skill es descubrible y ejecutable antes de versionarlo.
1. Listar los skills configurados:
find .github/skills -maxdepth 2 -type f
Salida esperada: el listado muestra feature-intake-spec-checklist/SKILL.md y sus dos ejemplos; esto confirma que el Skill esta en la ruta que Copilot descubre automaticamente en el repositorio.
2. Prompt para ejecutar el Skill (Copilot Chat):
Actua como el Skill feature-intake-spec-checklist
(.github/skills/feature-intake-spec-checklist/SKILL.md).
Usa como entrada el contenido de examples/input.sample.md y genera
UNICAMENTE el documento Output definido en el contrato del Skill.
Salida esperada: Copilot Chat responde con un unico documento Markdown con las nueve secciones del contrato (Summary, Scope, Assumptions ... Open questions), coherente con examples/output.sample.md y sin inventar datos fuera de la entrada.
3. Commit y tag:
git add .github/skills/feature-intake-spec-checklist
git commit -m "Add basic skill: feature intake to spec checklist (v0.1.0)"
git tag skill-feature-intake-v0.1.0
Criterio de salida: el Skill es descubrible en .github/skills/, produce el documento esperado al invocarlo desde Copilot Chat y queda versionado con commit y tag.
06
Aplicar el Skill a la HU-01
Tiempo estimado: 15-20 minutos. HU-01.md no se copia: se genera desde el HALLAZGOS.md de tu workshop-auth-backend del Dia 1 (filas "Pendiente" sobre el token).
CONTEXTO
workshop-auth-backend/HALLAZGOS.md es la matriz de hallazgos del Dia 1.

OBJETIVO
Generar workshop-auth-backend/HU-01.md a partir de las filas "Pendiente"
de HALLAZGOS.md relacionadas con el token de autenticacion.

RESTRICCIONES
No inventes hallazgos que no esten en HALLAZGOS.md. No incluyas valores de
tokens, secretos ni credenciales.

CRITERIOS DE ACEPTACION
HU-01.md tiene las secciones Origen, Contexto, Ajustes necesarios, Criterios de
aceptacion y Evidencia esperada. Origen lista los Id (H-xx) y la evidencia
archivo:linea de cada hallazgo usado. Cada criterio de aceptacion es
verificable con una prueba.

FORMATO DE RESPUESTA
Solo el archivo HU-01.md.
Solo si tu HALLAZGOS.md no tiene hallazgos de token en estado "Pendiente", crea HU-01.md y pega esta version de referencia:
# HU-01 - Token firmado con expiracion y claims minimos

## Veredicto
**Usable con ajustes.** La historia conecta seguridad, configuracion, testing y evidencia.

## Contexto
El servicio de autenticacion expone `POST /auth/login` y devuelve `token`, `expiresIn` y `user`. La implementacion usa firma HMAC y lee `AUTH_TOKEN_SECRET`.

## Ajustes necesarios
- Exigir los claims `sub`, `client`, `iat` y `exp`.
- Obtener `client` desde la solicitud, validarlo y reflejarlo en el token.
- Comprobar que `expiresIn` coincide con `exp - now` usando una tolerancia documentada.
- Eliminar el secreto por defecto fuera del sandbox o documentarlo como exclusivo de laboratorio.
- Evitar logs del token y del secreto.
- Mantener como decision tecnica si se conserva HMAC o se adopta una libreria JWT.

## Criterios de aceptacion
- Un token valido contiene `sub`, `client`, `iat` y `exp`.
- `expiresIn` es coherente con `exp - now` dentro de la tolerancia definida.
- Login valido, credenciales invalidas y token expirado tienen pruebas.
- No se registran tokens, secretos ni valores sensibles.
- La decision sobre HMAC frente a una libreria JWT queda documentada.

## Evidencia esperada
- Documento generado por los Skills a partir de este archivo.
- Pruebas de claims, expiracion y errores de autenticacion.
- Configuracion documentada de `AUTH_TOKEN_SECRET`.
- Evidencia de logs redactados.
Comprobacion: confirma que el archivo existe y que Copilot Chat puede leerlo desde la raiz del repositorio.
test -f HU-01.md && cat HU-01.md
Prueba: Genera tu Prompt para usar este skill con el archivo creado (HU-01.md). Puedes tambien usar el siguiente Prompt:
Actua como el Skill feature-intake-spec-checklist
(.github/skills/feature-intake-spec-checklist/SKILL.md).

Lee workshop-auth-backend/HU-01.md y usa el archivo como unica entrada.
Genera UNICAMENTE el documento Output definido en el contrato del Skill,
con sus nueve secciones: Summary, Scope (in/out), Assumptions,
Technical decisions to make, Risks and mitigations, Acceptance criteria,
Validation plan, Suggested tasks by role y Open questions.

No inventes requisitos. Marca como pregunta abierta toda decision que la HU
no confirme. No incluyas valores de tokens, secretos ni credenciales.
Revisar el resultado: verifica que la respuesta cubra los claims sub, client, iat y exp; la relacion entre expiresIn y exp; la configuracion segura de AUTH_TOKEN_SECRET; ausencia de logs sensibles; pruebas de token, expiracion y claims; y tareas para Tech Lead, Backend y QA. La decision HMAC frente a una libreria JWT debe quedar como una decision tecnica o pregunta abierta, no como un hecho inventado.
Criterio de salida: HU-01.md esta versionado en la raiz, el Skill lee el archivo como entrada y produce un documento trazable, sin secretos, con criterios de aceptacion verificables y preguntas abiertas donde falte confirmacion.
07
Versionar el laboratorio
Tiempo estimado: 5 minutos. Sube todo lo trabajado en S1 (Skill y HU-01.md) y marca el laboratorio con un tag.
git add -A
git commit -m "lab02-s1: skill basico feature-intake-spec-checklist + HU-01"
git push origin HEAD
git push origin skill-feature-intake-v0.1.0
git tag lab02-s1
git push origin lab02-s1
Criterio de salida: el repositorio remoto contiene .github/skills/feature-intake-spec-checklist/, HU-01.md y el tag lab02-s1 apunta al commit final del laboratorio (ademas de skill-feature-intake-v0.1.0).
Qué obtengo
  • .github/skills/feature-intake-spec-checklist/ con SKILL.md, examples/input.sample.md, examples/output.sample.md
  • Demostracion de descubrimiento y ejecucion del Skill desde Copilot Chat
  • HU-01.md revisada por el Skill y un resultado trazable de contrato y seguridad
  • Commit y tag skill-feature-intake-v0.1.0
  • Commit y tag lab02-s1 con todo el laboratorio versionado
11:4513:00
Laboratorio S2

Skills desde el catalogo (onboarding + ciclo SDLC)

Registrar tu repositorio en el catalogo central skills-catalog, instalar 6 Skills via ISSUE y simular un ciclo SDLC (API, Backend, Frontend, Test, docs y Review) sobre los tres workshops.

1 h 15
Materiales
  • reqflow-workspace/ del Dia 1 con tus 3 repos propios (los comandos de S2 se ejecutan desde ahi): workshop-auth-backend, workshop-login-frontend, workshop-requirements-api
  • workshop-auth-backend/.github/skills/feature-intake-spec-checklist ya creado en S1
  • Acceso para crear ISSUES en NTTData-Academy/bcp-ai-skill-catalog (plantillas repo-onboarding y skills-install)
  • HU-01 local: workshop-auth-backend/HU-01.md ya existe; la generaste en S1 desde tu HALLAZGOS.md del backend.
  • HU-05 local: genérala con el mismo prompt de S1, leyendo workshop-login-frontend/HALLAZGOS.md (hallazgo de innerHTML en estado "Pendiente").
  • Los Skills de S2 reciben tambien docs/ENDPOINTS.md y docs/TESTING.md del Dia 1 como punto de partida.
  • Solo si tu HALLAZGOS.md no tiene esos hallazgos "Pendiente", crea los archivos y pega las versiones de referencia de abajo.
  • touch HU-01.md HU-05.md
  • # HU-01.md
    # HU-01 - Token firmado con expiracion y claims minimos
    
    ## Origen
    - Hallazgos de token del backend en `HALLAZGOS.md` (Id `H-xx` de tu Dia 1).
    
    ## Veredicto
    **Usable con ajustes.** La historia conecta seguridad, configuracion, testing y evidencia.
    
    ## Contexto
    El servicio de autenticacion expone `POST /auth/login` y devuelve `token`, `expiresIn` y `user`. La implementacion usa firma HMAC y lee `AUTH_TOKEN_SECRET`.
    
    ## Ajustes necesarios
    - Exigir los claims `sub`, `client`, `iat` y `exp`.
    - Obtener `client` desde la solicitud, validarlo y reflejarlo en el token.
    - Comprobar que `expiresIn` coincide con `exp - now` usando una tolerancia documentada.
    - Eliminar el secreto por defecto fuera del sandbox o documentarlo como exclusivo de laboratorio.
    - Evitar logs del token y del secreto.
    - Mantener como decision tecnica si se conserva HMAC o se adopta una libreria JWT.
    
    ## Criterios de aceptacion
    - Un token valido contiene `sub`, `client`, `iat` y `exp`.
    - `expiresIn` es coherente con `exp - now` dentro de la tolerancia definida.
    - Login valido, credenciales invalidas y token expirado tienen pruebas.
    - No se registran tokens, secretos ni valores sensibles.
    - La decision sobre HMAC frente a una libreria JWT queda documentada.
    
    ## Evidencia esperada
    - Documento generado por los Skills a partir de este archivo.
    - Pruebas de claims, expiracion y errores de autenticacion.
    - Configuracion documentada de `AUTH_TOKEN_SECRET`.
    - Evidencia de logs redactados.
  • # HU-05.md
    # HU-05 - Eliminar `innerHTML` en mensajes de login
    
    ## Origen
    - Hallazgo de `innerHTML` del frontend en `HALLAZGOS.md` (Id `H-xx` de tu Dia 1).
    
    ## Veredicto
    **Usable directamente.** El hallazgo existe y el cambio es acotado, observable y facil de probar.
    
    ## Estado actual
    `login.component.html` usa `[innerHTML]` para renderizar `message`, y `login.component.ts` construye mensajes con etiquetas HTML.
    
    ## Ajustes recomendados
    - Cambiar el mensaje a texto plano.
    - Usar interpolacion Angular: `{{ message }}`.
    - Eliminar `<strong>` y `<br>` de los valores dinamicos.
    - Mapear 400, 401 y 500 a mensajes genericos.
    - Mantener detalles tecnicos solo en logs controlados, sin credenciales.
    
    ## Criterios de aceptacion
    - No existe `[innerHTML]` en el flujo de login.
    - Los mensajes se muestran como texto plano.
    - Errores backend se convierten a mensajes genericos.
    - Hay al menos una prueba para el mapeo de errores.
    - El login valido y el logout no se rompen.
    
    ## Uso en el Dia 2
    - S1: Skill de seguridad frontend.
    - S2: template de cambio y pruebas.
    - S3: tool de busqueda de patrones inseguros.
    - W1: evidencia de diff, test y comportamiento.
  • Skills del catalogo a instalar (set base ReqFlow; se reutiliza en el Dia 3): discovery-analysis (quality), spec-writing (specification), architecture-decision (architecture), issue-implementation (quality), reqflow-definition-of-done (review)

A diferencia de S1, aqui los Skills no se escriben a mano: se solicitan mediante ISSUES al catalogo central (skills-catalog) y un workflow los copia automaticamente a .github/skills/ de tu repositorio, registrando ademas el repositorio y sus dominios en subscribers.json.

Pasos
01
Verificar prerrequisitos: workshops y Skill de S1
Tiempo: 5 minutos. Desde reqflow-workspace/, confirma que los tres repos y el Skill de S1 existen antes de continuar.
test -d workshop-auth-backend && echo "OK: workshop-auth-backend"
test -d workshop-login-frontend && echo "OK: workshop-login-frontend"
test -d workshop-requirements-api && echo "OK: workshop-requirements-api"
test -d workshop-auth-backend/.github/skills/feature-intake-spec-checklist && echo "OK: skill de S1"
Si falta alguno de los repos, no clones la plantilla limpia: créalo como repo propio con el paso 1 del README del Dia 1, o parte de la rama checkpoint/day1.
Salida esperada: los cuatro test confirman presencia.
02
Onboarding del repositorio en el catalogo
Tiempo: 10-15 minutos. Antes de instalar Skills, tu repositorio debe existir en subscribers.json del catalogo. Crea el ISSUE desde el navegador, sin marcar ningun dominio: eso se registrara solo mas adelante, cuando instales los Skills en el paso 04.
1. Abre tu navegador de preferencia y ve a: https://github.com/NTTData-Academy/bcp-ai-skill-catalog/issues
2. Haz clic en New issue y selecciona la plantilla Onboarding de nuevo repositorio.
3. Revisa que el label repo-onboarding quede preseleccionado (campo Labels en la barra lateral del ISSUE).
4. En el campo Repositorios destinos escribe tus tres repos, sin el owner y uno por linea: workshop-auth-backend, workshop-login-frontend, workshop-requirements-api.
5. En Dominios iniciales (Opcional) no marques ninguna casilla: para este laboratorio los dominios se registran automaticamente al instalar los Skills en el paso 04.
6. Haz clic en Submit new issue.
Salida esperada: el workflow onboard-repo-on-issue.yml se ejecuta, agrega .github/workflows/sync-skills.yml a tu repositorio, registra tu repositorio (con dominios []) en subscribers.json, comenta el resultado en el ISSUE y lo cierra automaticamente si todo fue correcto.
03
Explorar el catalogo de Skills disponibles
Tiempo: 5-10 minutos. Consulta SKILLS-MANIFEST.json filtrando los dominios que usaras en este laboratorio: api, backend, frontend, test, governance y review.
curl -s https://raw.githubusercontent.com/NTTData-Academy/bcp-ai-skill-catalog/main/SKILLS-MANIFEST.json \
  | jq -r '.skills[] | select(.domain=="api" or .domain=="backend" or .domain=="frontend" or .domain=="test" or .domain=="governance" or .domain=="review") | "\(.domain) -> \(.identifier): \(.description)"'
Salida esperada: identificas, entre otros, discovery-analysis, spec-writing, architecture-decision, issue-implementation y reqflow-definition-of-done, que son los que instalaras en el siguiente paso.
04
Solicitar la instalacion de los Skills base de ReqFlow (los mismos del Dia 3)
Tiempo: 10-15 minutos. Crea el ISSUE desde el navegador y marca exactamente los Skills del set base.
1. En https://github.com/NTTData-Academy/bcp-ai-skill-catalog/issues, haz clic en New issue y selecciona la plantilla Instalar / actualizar Skills en un repositorio.
2. Revisa que el label skills-install quede preseleccionado.
3. En Repositorios destinos escribe los mismos tres repos usados en el paso 02.
4. Marca solo estas casillas:
  • Dominio: architecture → architecture-decision
  • Dominio: quality → discovery-analysis y issue-implementation
  • Dominio: review → reqflow-definition-of-done
  • Dominio: specification → spec-writing
Deja sin marcar el resto de casillas y secciones de dominio. Haz clic en Submit new issue.
Si por algun motivo tu repositorio no quedo registrado en el paso 02, el workflow lo detecta y dispara el onboarding automaticamente antes de instalar los Skills.
Salida esperada: install-skills-on-issue.yml crea un commit por Skill y hace push a la rama por defecto de tu repositorio, actualiza los dominios en subscribers.json, comenta el resultado en el ISSUE y lo cierra si todo fue correcto.
05
Sincronizar los Skills instalados en tu equipo
Tiempo: 5 minutos. Los commits los crea el bot del catalogo directamente en tu repositorio remoto; trae esos cambios a tu clon local.

Desde reqflow-workspace/

for r in workshop-auth-backend workshop-login-frontend workshop-requirements-api; do
  git -C "$r" pull origin main
  find "$r/.github/skills" -maxdepth 1 -type d
done
Salida esperada: junto a feature-intake-spec-checklist (S1), ahora ves 5 carpetas nuevas: discovery-analysis, spec-writing, architecture-decision, issue-implementation y reqflow-definition-of-done.
06
Discovery - Encontrar hallazgos y seleccionar un issue candidato
Tiempo: 10-15 minutos. Usa discovery-analysis para analizar el producto ReqFlow (multi-repo) y producir una lista corta de hallazgos con evidencia. No modifiques codigo.
Actua como el Skill discovery-analysis
(.github/skills/discovery-analysis/SKILL.md).

Contexto: estas en reqflow-workspace/ con los tres repos:
- workshop-auth-backend
- workshop-login-frontend
- workshop-requirements-api

Objetivo: produce 3-5 hallazgos con evidencia concreta (archivo:linea o comando),
impacto, prioridad propuesta, contrato potencialmente afectado y como validarlo.

Restricciones:
- no modificar codigo;
- no crear issues automaticamente;
- marca todo como CANDIDATO y detente para revision humana.
Salida esperada: 3-5 hallazgos con evidencia (Estado: CANDIDATO) listos para convertir en Issue tras gate humano.
07
Spec - Especificar el cambio aprobado
Tiempo: 10-15 minutos. Usa spec-writing para convertir el hallazgo/Issue aprobado en una spec verificable (sin diseno ni implementacion).
Actua como el Skill spec-writing
(.github/skills/spec-writing/SKILL.md).

Fuente: usa como entrada el hallazgo/Issue aprobado (titulo + evidencia + impacto).
Incluye contratos protegidos de ReqFlow cuando aplique.

Entrega solo la spec en el formato sugerido por el Skill y detente para
revision humana.
Salida esperada: spec verificable con alcance, fuera de alcance, criterios de aceptacion y contratos protegidos.
08
Architecture - Decidir estrategia y pruebas a proteger
Tiempo: 10-15 minutos. Usa architecture-decision para evaluar impacto, estrategia incremental y pruebas necesarias antes de implementar.
Actua como el Skill architecture-decision
(.github/skills/architecture-decision/SKILL.md).

Entrada: spec aprobada.
Salida: impacto, componentes, contratos protegidos, estrategia incremental,
pruebas necesarias, riesgos/trade-offs y decisiones abiertas.

Detente para revision humana antes de implementar.
Salida esperada: plan tecnico incremental y testeable (sin reescrituras ni cambios fuera de alcance).
09
Implementation - Implementar un issue aprobado con evidencia
Tiempo: 15-20 minutos. Usa issue-implementation para guiar la implementacion incremental del Issue aprobado, con pruebas y PR auditable.
Actua como el Skill issue-implementation
(.github/skills/issue-implementation/SKILL.md).

Precondiciones:
- issue aprobado
- spec aprobada
- impacto/arquitectura aprobada

Implementa el cambio minimo necesario, ejecuta pruebas relevantes y prepara
un PR con evidencia real.
Salida esperada: implementacion acotada + evidencia de pruebas/validaciones, lista para PR.
10
Review - Evaluar el cambio con DoD de ReqFlow
Tiempo: 8-10 minutos. Usa reqflow-definition-of-done como evaluator final basado en evidencia.
Actua como el Skill reqflow-definition-of-done
(.github/skills/reqflow-definition-of-done/SKILL.md).

Evalua el cambio propuesto/implementado para el Issue trabajado en S2.

Para cada criterio responde solo con:
- CUMPLIDO (citar evidencia)
- FALTA EVIDENCIA (decir que falta)
- BLOQUEADO (explicar causa)
- NO APLICA AL ALCANCE (justificar)
- PENDIENTE DE OTRO GATE (indicar cual)

No inventes ejecuciones de CI ni cobertura.
Salida esperada: evaluacion DoD con evidencia/citas y una decision explicita de si el cambio puede avanzar a PR.
11
Versionar el laboratorio
Tiempo: 5 minutos. Sube todo lo trabajado en S2 (Skills instalados, cambios de HU-01/HU-05, matriz de pruebas y evidencia) y marca el laboratorio con un tag.
git add -A
git commit -m "lab02-s2: skills catalog onboarding + ciclo SDLC (HU-01, HU-05)"
git push origin HEAD
git tag lab02-s2
git push origin lab02-s2
Criterio de salida: el repositorio remoto contiene los 6 Skills instalados, los cambios de HU-01 y HU-05, SDLC-EVIDENCE.md, y el tag lab02-s2 apunta al commit final del laboratorio.
Qué obtengo
  • Repositorio registrado en subscribers.json del catalogo, con .github/workflows/sync-skills.yml instalado
  • .github/skills/ con 6 Skills del catalogo (api, backend, frontend, test, governance, review) junto al de S1
  • Contrato API, ajuste de backend (HU-01) y ajuste de frontend (HU-05) generados con sus respectivos Skills
  • Matriz de pruebas y SDLC-EVIDENCE.md con la revision final
  • Commit y tag lab02-s2 con todo el laboratorio versionado
Almuerzo · 13:00-14:00
14:0015:20
Laboratorio S3

MCP con permisos explicitos

Exponer recursos con permisos, logs y decision humana.

1 h 20
Materiales
  • GitHub CLI autenticado y acceso a un repositorio de laboratorio.
  • Podman para levantar el MCP local.
  • VS Code con Copilot Chat en modo Agent.
  • Repositorio de practica donde crear .vscode/mcp.json.
  • No uses repositorios productivos ni muestres tokens en capturas.
git --version
gh --version
podman --version
bash --version
gh auth status

Si GitHub Projects requiere permisos adicionales, ejecuta gh auth refresh -s project. Los permisos efectivos dependen de la cuenta, los scopes, la organizacion y el repositorio.

Pasos
01
Levantar el MCP local
Tiempo: 20-30 minutos. Clona y construye la imagen base; despues el wrapper HTTP de tools/mcp-local/ la expondra en http://localhost:8081/mcp. El servidor original usa stdio; mcp-proxy solo transforma el transporte a HTTP.
git clone https://github.com/kunwarVivek/mcp-github-project-manager.git
cd mcp-github-project-manager
podman build -t localhost/mcp-github-project-manager:latest .
podman images localhost/mcp-github-project-manager

Desde bcp-ai-lab-day-02/s3_mcp/tools/mcp-local

export GITHUB_TOKEN="$(gh auth token)"
export GITHUB_OWNER="TU_OWNER"
export GITHUB_REPO="TU_REPO_DE_PRUEBA"
podman build -f Dockerfile -t localhost/mcp-http:latest .
podman compose --in-pod false up --build

En otra consola

curl -i http://localhost:8081/mcp
podman ps
Salida esperada: imagen base creada, contenedor en ejecucion, puerto 8081 publicado y respuesta HTTP. Antes de inicializar una sesion MCP, un 400 Bad Request por ausencia de sessionId es valido: el endpoint existe. No copies tokens al YAML ni crees Custom Agents o Skills.
02
Conectar VS Code y descubrir tools
Tiempo: 15-20 minutos. En la raíz de reqflow-workspace/ (no dentro de un repo) crea .vscode/mcp.json, abre Copilot Chat en modo Agent estandar y habilita el servidor local.
{
  "servers": {
    "github-local": {
      "type": "http",
      "url": "http://localhost:8081/mcp"
    }
  }
}
En Configure Tools, verifica que aparezca github-local (o el nombre derivado del servidor) y habilita discover_tools y manage_issues. Para la primera prueba deshabilita temporalmente las Built-in agent, browser, edit, execute, search, todo, vscode y web. Mantén read habilitada: solo puede procesar resultados MCP grandes almacenados por VS Code, no obtiene datos de GitHub.
Usa exclusivamente la herramienta MCP discover_tools.

Busca que herramienta y que accion permiten listar issues de un repositorio.
No uses terminal, archivos locales, web ni ninguna otra herramienta.
Salida esperada: identificar manage_issues con action = list.
03
Consultar issues y comprobar permisos locales
Tiempo: 20 minutos. Los repos de laboratorio aun no tienen issues (los del backlog, uno por HU, se crean en el paso 04): primero crea un issue temporal con una escritura controlada y despues léelo. Sustituye <OWNER> y <REPO> por el repositorio configurado. Revisa la llamada propuesta antes de autorizar la escritura.
Usa la herramienta MCP manage_issues.

Ejecuta la accion "create" con estos parametros:
owner: <OWNER>
repo: <REPO>
title: MCP local - write permission test
body: Issue temporal creado para validar permisos del laboratorio MCP.

No uses terminal, GitHub CLI, web ni archivos del workspace.
Antes de ejecutar, muestrame la tool MCP y los parametros que vas a enviar.
Ahora que existe al menos un issue, léelo y observa la invocacion MCP y sus parametros como evidencia de que GitHub se consulto mediante el servidor local.
Usa la herramienta MCP manage_issues.

Ejecuta la accion "list" con estos parametros:
owner: <OWNER>
repo: <REPO>
state: open

No uses terminal, GitHub CLI, web, archivos locales ni ninguna otra herramienta.
Resume numero, titulo y estado de cada issue.
Evidencia esperada: una llamada equivalente a Ran Manage Issues con action: list, owner, repo y state: open que devuelve el issue temporal. Luego inicia un chat nuevo y prueba: Usando el MCP local, consulta los issues abiertos de <OWNER>/<REPO> y resume numero, titulo y estado. Compara la seleccion automatica de la tool con la invocacion explicita.
Cierra o elimina el issue temporal. Explica donde se aplica una restriccion: tool expuesta, configuracion del servidor, scope del token, permiso de la cuenta o GitHub. La conclusion es: tool visible != permiso efectivo.
04
Conectar GitHub MCP oficial y comparar
Tiempo: 20-25 minutos. Agrega el servidor remoto oficial al mismo .vscode/mcp.json. Completa el flujo de autenticacion soportado por tu organizacion; no incluyas tokens en archivos versionados.
{
  "servers": {
    "github-official": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "github-official-readonly": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "X-MCP-Toolsets": "issues,repos,pull_requests",
        "X-MCP-Readonly": "true"
      }
    }
  }
}
Que tools MCP tienes disponibles en github-official?
No ejecutes ninguna; agrupelas por proposito.

Usando exclusivamente github-official, consulta los issues abiertos de OWNER/REPO y resume numero, titulo 
y estado.
No uses terminal, GitHub CLI, busquedas del workspace ni archivos locales.
Registra que tool oficial resolvio la lectura y compárala con manage_issues del MCP local. Despues crea el backlog que reutilizan los Dias 3 y 4: un issue por cada HU del dia, en el repo donde vive cada HU (<OWNER>/workshop-auth-backend para HU-01, <OWNER>/workshop-login-frontend para HU-05). Titulo: el titulo de la HU. Cuerpo: la seccion Origen (Id H-xx y evidencia archivo:linea), los Criterios de aceptacion como checklist y el enlace al PR de S2 si existe. Revisa la tool MCP antes de autorizar cada creacion. Si la escritura es rechazada, conserva el rechazo como evidencia de permisos y crea los issues desde la interfaz web: el Dia 3 los necesita igual.
Crea el Project ReqFlow bajo tu owner (una sola vez; los Dias 3 y 4 lo reutilizan), agrega cada issue y completa el campo Hallazgo origen con el Id H-xx:

Reemplaza TU_OWNER y URL_DEL_ISSUE con tus valores

owner="TU_OWNER"
issue_url="URL_DEL_ISSUE"
project_number="$(gh project create --owner "$owner" --title ReqFlow --format json --jq .number)"
gh project field-create "$project_number" --owner "$owner" --name "Hallazgo origen" --data-type TEXT
gh project item-add "$project_number" --owner "$owner" --url "$issue_url"
En Configure Tools, comprueba que github-official-readonly solo expone lectura y ejecuta una consulta real. Opcionalmente solicita una creacion; si no existe tool de escritura, indícalo y no busques otro mecanismo.
Cierre: mcp.json, toolsets y read-only reducen capacidades del cliente, pero no son la unica frontera de seguridad. Aplica scopes minimos, permisos GitHub minimos, rulesets/policies y solo las tools necesarias.
05
Versionar el laboratorio
Tiempo estimado: 5 minutos. reqflow-workspace/ no es un repo git: versiona dentro de cada repo que tocaste. Guarda la evidencia en docs/mcp-evidence/ más una copia de tu .vscode/mcp.json sin tokens; el original se queda en la raíz del workspace.

Desde reqflow-workspace/, en cada repo que cambiaste

cd workshop-auth-backend
mkdir -p docs/mcp-evidence
cp ../.vscode/mcp.json docs/mcp-evidence/mcp.json
git add -A
git commit -m "lab02-s3: mcp local + github mcp oficial con permisos explicitos"
git push origin HEAD
git tag lab02-s3
git push origin lab02-s3
Cierra además el día (igual que el Día 1), en cada repo que cambiaste: git tag day2-done, git push --follow-tags.
Criterio de salida: cada repo remoto que cambiaste contiene docs/mcp-evidence/ (con la copia de mcp.json sin tokens ni secretos), el tag lab02-s3 apunta al commit final del laboratorio y existe el tag day2-done.
Qué obtengo
  • MCP local levantado con Podman y endpoint HTTP accesible.
  • Servidor local y GitHub MCP oficial visibles y usados desde VS Code.
  • Evidencia de discover_tools, consulta real de issues y una prueba de permisos o restriccion.
  • Validacion de lectura con el servidor oficial y su configuracion read-only.
  • Comparacion documentada: mantenimiento, ejecucion, transporte, capacidades, configuracion y autorizacion.
  • Explicacion demostrable del flujo Modelo -> MCP -> GitHub, sin Custom Agents, Skills ni SDD.
  • Commit y tag lab02-s3 con todo el laboratorio versionado

Criterio de salida: el participante distingue entre capacidades expuestas por un servidor MCP, seleccion de tools por el modelo y autorizacion efectiva de GitHub.

Descanso · 15:20-15:30
HANDOFF · cierre del día

Checklist para iniciar el Día 3

Desde reqflow-workspace/, ejecuta el chequeo. Si falla, no continúes al Día 3.

python tools/check_handoff.py --day 2 ../reqflow-workspace
W1 · 15:30-18:00

Evaluacion practica sobre ReqFlow

Cada asistente recibe un requisito diferente y trabaja en su repositorio individual.

20 %Requisito + SDD
20 %Skill
20 %Implementacion
20 %Tools + MCP
20 %Tests + review

Umbral: >= 80 % · Issue, PR, prompts y evidencia obligatorios.

Verifica que existan
  • HU-*.md en la raiz de su repo, cada una con su seccion Origen (H-xx).
  • Un issue por HU, en el repo de la HU, agregado al Project ReqFlow con el campo Hallazgo origen.
  • .github/skills/ en cada repo, y reqflow-workspace/.vscode/mcp.json.
  • docs/mcp-evidence/mcp.json (copia sin tokens) en cada repo que cambiaste.
  • El tag day2-done en cada repo que cambiaste (se crea en el paso 05 de S3, junto al tag lab02-s3).
Chequeo de salida
  • Verifica desde la carpeta del laboratorio (al menos 1 repo en [OK] y mcp.json presente): python tools/check_handoff.py --day 2 ../reqflow-workspace
  • Si el chequeo falla, el Dia 3 parte de la rama checkpoint/day2 que entrega el instructor.
  • El Dia 3 no crea backlog nuevo: trabaja sobre tu Project ReqFlow.