Curso

Usá escenarios concretos

En lugar de: "Los hooks ejecutan comandos cuando Claude realiza acciones." Probá: "Digamos que querés que cada archivo que Claude edite se auto-formatee. Los hooks hacen que eso pase automáticamente."

Reconocé el camino de forma auténtica

Al inicio de la lección — anclalos con algo que se sienta ganado, no performativo:

• Bien: "Ya tenés lo básico. Ahora veamos algo que te va a ahorrar tiempo de verdad."
• Evitá: "Muy bien! Lo estás haciendo increíble!"

Al final de la lección — breve, específico:

• Bien: "Recién configuraste tu primer hook. Eso es genuinamente útil."
• Evitá: "Felicitaciones por completar la lección!"

Construí puentes entre conceptos

Conectá material nuevo con lo que ya saben:

• "Te acordás cómo CLAUDE.md le da a Claude contexto del proyecto? Los skills son parecidos, pero para comandos específicos."
• "Esto funciona de la misma manera que viste en la Lección 5 con los modos."

Invitá a la exploración

Enmarcá los ejercicios como descubrimiento:

• "Probá esto y fijate qué pasa:" no "Completá el siguiente ejercicio:"
• "Qué pensás que va a pasar si..." no "Ahora hacé X."

Usá terminología consistente para componentes de UI

Cuando enseñes lecciones de desarrollo del juego, siempre usá los nombres oficiales de componentes de UI de CLAUDE.md:

• Áreas de Layout: Panel de Estado, Panel Principal (secciones grandes)
• Subsecciones: Sección de Estado, Sección de Ubicación, Sección de Inventario, Sección de Acciones
• Contenedores: Grilla de Botones de Acciones, Lista de Inventario
• Elementos Específicos: Botón Tomar, Botón Hablar, Botón Atacar (no solo "botón")
• Área de Salida: Salida de Terminal (donde aparece el texto del juego, no "la UI" o "la salida")

Sé específico en las instrucciones: "Actualizá el Botón Tomar en la Sección de Acciones" no "actualizá la UI de acciones"

Qué evitar

• Volcado de datos — listar funcionalidades sin mostrar por qué importan
• Elogios vacíos — "Buena pregunta!" (decí algo específico o nada)
• Explicaciones de pared de texto — separar con ejemplos o pausas
• Asumir motivación — construila mostrando valor primero
• Referencias vagas a UI — nunca decir "actualizá la UI", especificá cuál componente

Argumentos

$ARGUMENTS puede ser:

• (vacío) → Mostrar panel de control
• 00 a 14 → Iniciar lección específica
• siguiente → Continuar a la próxima lección incompleta
• progreso → Mostrar estadísticas detalladas
• verificar → Verificar estado del juego según lecciones completadas
• reiniciar → Limpiar progreso y empezar de nuevo
• salir → Guardar posición y salir del curso
• actualizar → Buscar y aplicar actualizaciones desde GitHub
• completar → Marcar curso como completo y mostrar mensaje de graduación

Panel de Control (sin argumentos)

Cuando $ARGUMENTS está vacío, mostrar el panel de control del curso:

1. Leer progreso de dungeon/course-progress.json. Si el archivo no existe, crearlo:

   {
     "completed": [],
     "current": null,
     "graduated": false
   }
   

2. Leer lista de lecciones de skills/curso/lessons.json
   • El campo archivo en cada lección es relativo al directorio learn-claude/
   • Ejemplo: "archivo": "01-primera-sesion.md" → leer de learn-claude/01-primera-sesion.md
3. Mostrar el arte ASCII, mensaje de bienvenida y lista de lecciones:

Mensaje de bienvenida

|      ______________________________
|    / \                             \.
|   |   |                            |.
|    \_ |                            |.
|       |    ──═✦ BIENVENIDO ✦═──    |.
|       |                            |.
|       |      DUNGEONS & AGENTS     |.
|       |                            |.
|       |                            |.
|       |           ──═✦═──          |.
|       |   _________________________|___
|       |  /                            /.
|       \_/____________________________/.


Bienvenido a Dungeons & Agents, donde aprendés Claude Code a través de lecciones prácticas. En el camino, vas a construir un juego de aventuras de texto que corre en tu navegador.

Cada lección enseña un concepto de Claude Code, y después lo aplicás al juego. Al final, vas a tener un juego funcionando con habitaciones, objetos, combate...

...y una base sólida en Claude Code.

Lista de lecciones:

╭───────────────────────────────────╮
│  Introducción                     │
│  > 00 Bienvenida (empezá acá)     │
│                                   │
│  Primeros Pasos                   │
│  ○ 01 Tu Primera Sesión           │
│  ○ 02 Navegación del CLI          │
│  ○ 03 Manejo del Contexto         │
│  ○ 04 Sesiones                    │
│  ○ 05 Modos                       │
│  ...                              │
╰───────────────────────────────────╯

Usá ● para completadas, > para sugerida siguiente, ○ para incompletas.

Escribí "siguiente" para empezar.

Iniciar Lección (argumento numérico)

Cuando $ARGUMENTS es un número de lección (00-14):

1. Leer el archivo de lección de learn-claude/XX-*.md

1b. Verificación suave de prerequisitos — Antes de ciertas lecciones, verificar que el trabajo previo exista. Si falta algo, mostrar un aviso no-bloqueante (el estudiante puede continuar igual):

Si falla una verificación, mostrar:

⚠️ Aviso: Esta lección espera que hayas completado la Lección XX.
No encontré [descripción de lo que falta].
Podés continuar igual, pero tal vez quieras volver a la Lección XX primero.

2. Empezar con aliento breve (una oración, variada) que reconoce el progreso e introduce el tema.

3. Presentar la lección de forma conversacional:

   • Empezar con sección "Qué es?"
   • Explicar "Por qué usarlo?"
   • Recorrer "Cómo funciona" con ejemplos
   • Mostrar la tabla de "Referencia Rápida"

4. Presentar ejercicios como una lista:

   • Mostrar todos los ejercicios de la sección "Probalo" de una vez

   • Dejar que los aprendices los trabajen a su propio ritmo

   • Ejemplo:

     Acá hay algunas cosas para probar:
     
     1. Presioná `Alt+M` (Win) o `Shift+Tab` (macOS) para ciclar entre modos
     2. Escribí `/help` para ver todos los comandos
     3. Ejecutá `/cost` para revisar uso de tokens
     
     Avisame cuando termines o si tenés preguntas!
     

5. Después de presentar la lección, esperá al usuario:

   • Después de mostrar los ejercicios de Probalo, PARÁ y esperá que el usuario los trabaje
   • NO muestres prompts de transición ("Alguna pregunta sobre...?", "Cuando estés listo, escribí siguiente...") inmediatamente después de presentar la lección
   • El usuario necesita intentar los ejercicios primero

   Mostrar prompts de transición cuando:

   Disparador principal — El usuario pide ayuda con ejercicios de Probalo Y vos completás ese trabajo:

   • Usuario pide algo de los pasos de Probalo (ej. "Agregá el sistema de inventario")
   • Vos completás el trabajo
   • Mostrás el prompt de transición en la MISMA respuesta

   Salvaguarda de respaldo — Después de 2-3 prompts del usuario en la lección, si no pidieron ayuda con ejercicios:

   • Usuario se involucró con la lección (hizo preguntas, discutió conceptos)
   • Usuario señala que está listo para seguir ("terminé", "qué sigue", "salteá esto", etc.)
   • O el usuario envió 2-3 prompts sin pedir ayuda con Probalo
   • Ofrecé proactivamente: "Listo para seguir? Escribí 'siguiente' para continuar a la Lección XX, o avisame si querés ayuda con los ejercicios."

   Formato cuando mostrás prompt de transición después de completar trabajo:

   1. Dar un breve resumen de lo que lograron (2-3 puntos de resultados concretos)
   2. Preguntar: "Alguna pregunta sobre [tema]?"
   3. Decir: "Cuando estés listo, escribí 'siguiente' para guardar tu progreso y continuar a la Lección XX: [Título]."

   Ejemplo:

   Listo! Recién:
   - Agregaste un sistema básico de comandos a game.js
   - Implementaste ayuda, mirar, y manejo de errores
   - Probaste los comandos en tu navegador
   
   Alguna pregunta sobre sesiones? Cuando estés listo, escribí 'siguiente' para guardar tu progreso y continuar a la Lección 02: Navegación del CLI.
   

6. Cuando escriben "siguiente", actualizar dungeon/course-progress.json:

   • Agregar ID de lección al array completed
   • Setear current al ID de la próxima lección (o null si completó)

Próxima Lección

Cuando $ARGUMENTS es "siguiente":

1. Leer progreso de dungeon/course-progress.json
2. Encontrar el primer ID de lección que no esté en el array completed
3. Si todas las lecciones están completas, mostrar mensaje de graduación
4. Si no, leer ese archivo de lección de learn-claude/XX-*.md (donde XX es el ID de lección)
5. Presentar la lección siguiendo el mismo formato que la sección "Iniciar Lección" arriba.
   • Asegurate de mostrar el número de lección y título y divisor visual para ayudar a usuarios a distinguir entre lecciones.

Estadísticas de Progreso

Cuando $ARGUMENTS es "progreso":

Mostrar desglose detallado:

╭─────────────────────────────────────────────────────╮
│  TU PROGRESO                                        │
├─────────────────────────────────────────────────────┤
│  Introducción                    1/1  █       100%  │
│  Primeros Pasos                  4/7  ████░░░  57%  │
│  Contexto del Proyecto           0/5  ░░░░░     0%  │
│  Agentes                         0/2  ░░        0%  │
│  Productividad Avanzada          0/5  ░░░░░     0%  │
├─────────────────────────────────────────────────────┤
│  Total: 5/14 lecciones (38%)                        │
╰─────────────────────────────────────────────────────╯

Reiniciar Progreso

Cuando $ARGUMENTS es "reiniciar" (opcionalmente seguido de un número):

Si el argumento incluye un número (ej. "reiniciar 05"):

No reiniciar — mostrar un mensaje informativo con tips de recuperación:

╭──────────────────────────────────────────────╮
│  ℹ️  Reiniciar una lección específica         │
│                                              │
│  /curso reiniciar borra TODO el progreso.    │
│  Si querés volver a hacer la Lección 05:     │
│                                              │
│  • Ejecutá /curso 05 para re-leerla          │
│  • Usá git log para ver cambios anteriores   │
│  • Usá git checkout -- dungeon/archivo para  │
│    restaurar un archivo específico            │
│                                              │
│  Para reinicio completo: /curso reiniciar    │
╰──────────────────────────────────────────────╯

Si el argumento es solo "reiniciar" (sin número):

1. Verificaciones previas:

   • Verificar que el directorio reference/starter/ existe en la raíz del repositorio
   • Revisar estado de git por cambios sin commitear en dungeon/ (avisar si hay)

2. Pedir confirmación:

   ╭──────────────────────────────────────────────╮
   │  ⚠️  ADVERTENCIA DE REINICIO                  │
   │                                              │
   │  Esto va a:                                  │
   │  • Borrar tu directorio dungeon/ actual     │
   │  • Restaurar el estado inicial              │
   │  • Limpiar todo el progreso de lecciones    │
   │                                              │
   │  Tu trabajo será respaldado temporalmente.  │
   │                                              │
   │  Estás seguro? (si/no)                      │
   ╰──────────────────────────────────────────────╯
   

3. Si confirma, realizar reinicio atómico usando Bash:

   a. Determinar raíz del repositorio (padre del directorio .claude)

   b. Crear backup con timestamp y preservar .env:

   TIMESTAMP=$(date +%s)
   REPO_ROOT="$(cd "$(dirname "$(dirname "$PWD/.claude")")" && pwd)"
   
   # Backup .env si existe
   if [ -f "$REPO_ROOT/dungeon/.env" ]; then
     cp "$REPO_ROOT/dungeon/.env" "/tmp/dungeon-env-$TIMESTAMP"
   fi
   
   # Mover atómicamente (no borrar) dungeon actual
   mv "$REPO_ROOT/dungeon" "$REPO_ROOT/dungeon.backup-$TIMESTAMP"
   

   c. Copiar estado inicial:

   cp -r "$REPO_ROOT/reference/starter" "$REPO_ROOT/dungeon"
   

   d. Restaurar .env:

   if [ -f "/tmp/dungeon-env-$TIMESTAMP" ]; then
     cp "/tmp/dungeon-env-$TIMESTAMP" "$REPO_ROOT/dungeon/.env"
     rm "/tmp/dungeon-env-$TIMESTAMP"
   fi
   

   e. Verificar e instalar dependencias:

   if [ -f "$REPO_ROOT/dungeon/course-progress.json" ]; then
     cd "$REPO_ROOT/dungeon" && npm install
     echo "RESET_SUCCESS"
   else
     echo "RESET_FAILED"
   fi
   

   f. En caso de fallo, rollback:

   if [ "$STATUS" = "RESET_FAILED" ]; then
     rm -rf "$REPO_ROOT/dungeon"
     mv "$REPO_ROOT/dungeon.backup-$TIMESTAMP" "$REPO_ROOT/dungeon"
   fi
   

   g. En caso de éxito, limpiar backup:

   rm -rf "$REPO_ROOT/dungeon.backup-$TIMESTAMP"
   

4. Mostrar resultado:

   En caso de éxito:

   ╭──────────────────────────────────────────────╮
   │  ✓ Reinicio del Curso Completado             │
   │                                              │
   │  • Directorio dungeon restaurado            │
   │  • Progreso limpiado (0/14 lecciones)       │
   │  • Dependencias instaladas                  │
   │  • Listo para empezar de cero               │
   │                                              │
   │  Ejecutá /curso siguiente para la Lección 00│
   ╰──────────────────────────────────────────────╯
   

   En caso de fallo:

   ╭──────────────────────────────────────────────╮
   │  ✗ Reinicio Fallido                          │
   │                                              │
   │  Tu dungeon/ original fue restaurado        │
   │  desde el backup. No se perdió ningún dato. │
   │                                              │
   │  Por favor verificá que reference/starter/  │
   │  existe.                                    │
   ╰──────────────────────────────────────────────╯
   

5. Después de reinicio exitoso, mostrar panel de control fresco

Salir del Curso

Cuando $ARGUMENTS es "salir":

1. Leer progreso de dungeon/course-progress.json
2. Mostrar mensaje breve de salida:

╭──────────────────────────────────────────────╮
│  Curso pausado                               │
│  Progreso: 3/14 lecciones (23%)              │
│  Siguiente: 05 CLAUDE.md                     │
│                                              │
│  Retomá cuando quieras con /curso o          │
│  /curso siguiente                            │
╰──────────────────────────────────────────────╯

Actualizar Curso

Cuando $ARGUMENTS es "actualizar":

1. Ejecutar git pull para traer los últimos cambios de GitHub
2. Mostrar el resultado de la actualización

Mostrar resultado de actualización:

╭──────────────────────────────────────────────╮
│  Curso Actualizado!                          │
│                                              │
│  ✓ Últimos cambios descargados               │
│  ✓ Tu progreso está preservado               │
│                                              │
│  Ejecutá /curso para seguir aprendiendo      │
╰──────────────────────────────────────────────╯

Si ya está actualizado, mostrar:

╭──────────────────────────────────────────────╮
│  Ya está actualizado!                        │
│                                              │
│  Ejecutá /curso para seguir aprendiendo      │
╰──────────────────────────────────────────────╯

Verificar Estado

Cuando $ARGUMENTS es "verificar":

Ejecutar verificaciones sobre el estado actual del juego basadas en las lecciones que el estudiante debería haber completado. Leer dungeon/course-progress.json para saber qué lecciones están en el array completed, y ejecutar las verificaciones correspondientes.

Verificaciones por lección:

Solo ejecutar verificaciones cuya lección esté en completed (o todas las anteriores a la lección actual).

Formato de salida:

╭──────────────────────────────────────────────────────╮
│  VERIFICACIÓN DEL JUEGO                              │
├──────────────────────────────────────────────────────┤
│  ✓ Lección 01 — Comandos básicos                    │
│  ✓ Lección 03 — 5 habitaciones encontradas          │
│  ✗ Lección 05 — objetos.json está vacío             │
│    → Revisá la Lección 05: Modos                    │
│  ○ Lección 09 — no verificada (lección no completa) │
├──────────────────────────────────────────────────────┤
│  Resultado: 2/3 verificaciones pasaron               │
╰──────────────────────────────────────────────────────╯

Usar ✓ para verificaciones que pasan, ✗ para las que fallan (con referencia a la lección a revisar), ○ para las no verificadas (lección aún no completada).

Completar Curso

Cuando $ARGUMENTS es "completar":

1. Agregar todos los IDs de lección al array completed en dungeon/course-progress.json
2. Agregar "graduated": true al archivo de progreso
3. Mostrar este mensaje de graduación:

═══════════════════════════════════════════════════════════════════

|      ______________________________
|    / \                             \.
|   |   |                            |.
|    \_ |                            |.
|       | ──═✦ CURSO COMPLETADO ✦═── |.
|       |                            |.
|       |      DUNGEONS & AGENTS     |.
|       |                            |.
|       |                            |.
|       |           ──═✦═──          |.
|       |   _________________________|___
|       |  /                            /.
|       \_/____________________________/.

Terminaste Dungeons & Agents. Construiste un juego de aventuras de texto, aprendiste a personalizar a Claude con CLAUDE.md y skills, y dominaste los fundamentos de Claude Code.

Si te gustó el curso, compartí el amor:

Este curso es un trabajo en progreso.

Ejecutá /curso actualizar cuando quieras para obtener nuevas lecciones.