# Módulo 1 — Instalá Claude Code y armá tu base

### De pedirle cosas sueltas al chat a tener un asistente parado dentro de tus archivos

*Guía práctica para Dirigir la IA · para vos, que querés producir más en menos tiempo · primer paso después de la intro*

> **El chat se olvida cada vez. Tu base lo tiene escrito y retoma donde quedaste.**

---

## Cómo se usa esto

Este módulo **se hace leyendo y pegando**. Cada paso trae un recuadro **[COPIAR AL CHAT]**: copiás lo que
está adentro del recuadro, lo pegás en el chat de Claude y **mirás lo que devuelve antes de seguir**.

La primera vez, con calma: seleccionás el texto, `Ctrl+C` (en Mac `Cmd+C`); en Claude, `Ctrl+V` (`Cmd+V`)
y Enter. Después te sale solo.

Cada paso termina con una línea **Antes de seguir**: lo que tiene que haber pasado para pasar al siguiente.
Si eso no pasó, no avances — decíselo con palabras (*"pará, no era eso"*) y se corrige. **No se rompe nada.**

> **El primer paso es instalar**, porque hasta que no tengas dónde pegar, los recuadros no tienen destino.
> Ese es el único paso que se hace sin pegar nada.

Te lo explico con el **porqué y el cómo**, no pasos sueltos, para que después lo adaptes a tu trabajo.

---

## Dónde estás parado

Venís usando la IA en el chat de la web: le preguntás, te responde, cerrás la pestaña y **se olvidó de
todo**. Cada vez arrancás de cero, le repetís tu contexto y qué querés. Tu información vive repartida entre
mails, documentos, planillas y tu cabeza.

Eso no es falta de esfuerzo tuyo: es falta de **sistema**. Hoy lo arreglamos. Al terminar el módulo la IA
va a vivir **en tu computadora**, va a **ver tus archivos** y va a **seguir tus reglas** — sin que tengas
que re-explicarle tu caso cada vez.

---

## Pizca conceptual (el mínimo "por qué", sin ser técnico)

No hay que saber programar. Solo tres ideas:

- **Claude Code es el mismo Claude del chat, pero parado dentro de una carpeta tuya.** Ve, lee y crea
  archivos ahí adentro — siempre pidiéndote OK antes de tocar algo.
- **No programás: le escribís en castellano normal**, de a un pedido por vez. La "terminal" asusta, pero
  es solo *el lugar donde le hablás*. Y si usás la app de escritorio, ni siquiera ves una terminal.
- **Tu conocimiento va a vivir afuera del chat, en archivos tuyos.** Eso es lo que arreglamos hoy: que
  nada importante quede atrapado en una conversación que después se borra.

> **La diferencia en una frase:** el chat es un consultor brillante con amnesia. Claude Code es ese mismo
> consultor, pero con acceso a tu escritorio y a un cuaderno donde anota todo.

---

## El método en 60 segundos

Vamos a montar cuatro piezas:

1. **Tu base** — una **carpeta madre** que junta todo tu trabajo con IA, con un archivo `CLAUDE.md` que
   guarda tus reglas y te **recibe** cuando entrás.
2. **Tu ficha (`perfil.md`)** — qué hacés, qué querés lograr y cómo te gusta trabajar. La cargás **vos mismo/a**, dejando
   que la IA te entreviste.
3. **Las primeras reglas** de tu base — cómo querés que trabaje siempre (guardar lo aprendido, preguntar si
   duda, no borrar sin avisar…).
4. **Proyecto 0 (`00-aprendizaje`)** — tu hub de conocimiento: ahí cae todo lo que aprendas. Es
   **un proyecto más, hermano** de tus proyectos reales — no un cajón que los contiene.

**Cómo queda la estructura:**

```
tu-base/                  ← carpeta madre (la que manda). Acá vive el CLAUDE.md = tus reglas + recepcionista
├── CLAUDE.md
├── 00-aprendizaje/       ← tu proyecto 0 (tu conocimiento)
└── (tus proyectos reales)  ← cada uno su carpeta, al lado de 00-aprendizaje, no adentro
```

---

## Paso a paso (hacelo en este orden)

### Paso 1 — Instalá Claude Code

> ⚠️ Los detalles de instalación cambian seguido. Si te trabás en cualquier punto, **sacá una captura y
> guardala** para consultarlo — no avances a los tropezones.

Hay dos caminos. Elegí según con qué te sientas cómodo/a.

**Camino recomendado para no técnicos (Windows y Mac): la app de escritorio de Claude.**
Trae tres pestañas — **Chat**, **Cowork** y **Code** — y vas a trabajar en **Code** (Claude parado dentro
de tus carpetas). Sin terminal.

**En orden:**
1. **Contratá el plan Pro** en tu cuenta de Claude. Importante: **la cuenta gratis NO habilita la pestaña
   Code.** (Para empezar, Pro alcanza; existe Max para uso intensivo.)
2. **Bajá e instalá Claude Desktop** (Windows o Mac) desde claude.com e iniciá sesión.
3. Entrá a la pestaña **Code**.
   - **En Windows**, la primera vez te va a pedir instalar **Git para Windows** (un programita; lo instalás
     y **reiniciás la app**). Es de una sola vez.

> **[DATO]** Las tres pestañas: **Chat** para preguntar/redactar suelto, **Cowork** para que trabaje con tus
> archivos sin tanto detalle, y **Code** (la que vamos a usar) para que **recuerde todo** de un proyecto.

**Camino terminal (para quien lo prefiera):** instalás por línea de comandos
(`npm install -g @anthropic-ai/claude-code`, requiere Node LTS) o con el instalador nativo, y arrancás
escribiendo `claude` **parado en la carpeta**. En Windows abrís la carpeta en el Explorador y escribís
`cmd` en la barra de direcciones; en Mac/Linux hacés `cd` a la carpeta.

> ℹ️ **Si en vez de Claude Code usás Codex** (el equivalente de OpenAI): es la misma idea. El archivo de
> reglas se llama `AGENTS.md` en lugar de `CLAUDE.md`, y el comando para arrancar la base es `/init` en vez
> de crear el archivo a mano. Todo lo demás de este módulo aplica igual.

**Antes de seguir:** tenés la pestaña **Code** abierta (o el comando `claude` andando). Todavía no le
pegaste nada.

### Paso 2 — Creá la carpeta madre y pará la IA adentro

1. Creá a mano una carpeta madre donde va a vivir **todo** tu trabajo con IA. Llamala como quieras (ej.
   `proyectos`, `trabajo-ia`).
   - **Windows:** en el Explorador, clic derecho → Nuevo → Carpeta.
   - **Mac:** en Finder, clic derecho → Nueva carpeta.
2. Abrí esa carpeta con Claude Code:
   - **App de escritorio:** pestaña **Code → New session →** Environment **Local** → **Select folder** → elegí tu carpeta.
   - **Terminal:** parate en la carpeta y escribí `claude`.

> **[CLAVE] Dirigís la IA desde tu base. Y se carga solo el tema que necesitás.**
>
> Tu base **no** es una carpeta que la IA se lee entera — eso sería justo lo que la satura. **Tu base es
> desde dónde te parás.** Adentro está todo tu trabajo, y ella **lee lo que hace falta para lo que le
> pediste**.
>
> Por eso **no tenés que "entrar" a cada proyecto**: te parás en tu base, le decís en cuál estás, y abre
> lo de ese. Cambiás de tema y hacés lo mismo.

> **[CLAVE] Abrí siempre tu carpeta principal, no la de un proyecto.** Y trabajá en **una sola sesión**,
> aunque saltes de un proyecto a otro. La carpeta se elige **por sesión**, no una vez para toda la app:
> cada sesión nueva vuelve a preguntarte cuál, y **lo que hiciste en una no está en la otra**.
>
> Parado en la carpeta madre, tu asistente ve **tus reglas y todos tus proyectos**, y le decís en cuál
> trabajar con palabras (*"seguimos con el proyecto tal"*). Entrar directo a la carpeta de un proyecto no
> te da nada que no tengas — y te saca la vista del resto.
>
> **Cuál es "tu base", en concreto.** Es la **carpeta principal: la que tiene adentro todos tus proyectos**,
> la que creaste hace un rato y donde va a vivir tu `CLAUDE.md`. Cuando Claude te pida elegir carpeta, elegís
> **esa**, no las de adentro:
>
> ```
> tu-carpeta-principal/     ← ACÁ te parás. Esta es la que elegís al abrir.
> ├── CLAUDE.md             ← tus reglas
> ├── 00-aprendizaje/       ← un proyecto más
> └── (tus otros proyectos) ← NO abras acá
> ```
>
> **La confusión que esto evita, y que ya le pasó a un alumno:** *un chat por proyecto* parece orden, pero
> el chat **no es** donde vive la organización. La organización son **tus carpetas**; el chat es una
> conversación que se cierra. Un proyecto por carpeta ✓ — un chat por proyecto ✗.

**Antes de seguir:** tu asistente quedó parado en esa carpeta y tenés el cuadro de texto abajo listo para
escribirle. **De acá en adelante, todo es pegar.**

### Paso 3 — Cargá tu ficha: dejá que te entreviste

La primera ficha que armás **sos vos**. En vez de escribirla a mano, dejá que la IA te haga preguntas — de
paso aprendés la técnica de "entrevistame" que vas a reusar en cada proyecto.

> **[COPIAR AL CHAT]**
> ```
> Quiero convertir esta carpeta en mi base de trabajo con IA. Entrevistame de a UNA pregunta por vez
> (no todas juntas) para armar mi ficha: qué hago, qué quiero lograr con vos y cómo me gusta
> trabajar. Con mis respuestas creá un archivo perfil.md con mi ficha personal.
> Hablame siempre en castellano (voseo). Empezá por la primera pregunta.
> ```

Respondé con tus palabras. Si no entendés una pregunta, escribile *"explicámelo más simple"*.

**Antes de seguir:** existe el archivo `perfil.md` en tu carpeta y lo leíste una vez.

### Paso 4 — Ponele las primeras reglas a tu base (el `CLAUDE.md`)

Las reglas son **cómo querés que la IA trabaje siempre**. Se guardan en el `CLAUDE.md` de la carpeta madre,
y valen para todos tus proyectos.

> **[COPIAR AL CHAT]**
> ```
> Creá en esta carpeta un archivo CLAUDE.md con las reglas de cómo quiero que trabajes siempre, y
> explicame al final en dos líneas, sin tecnicismos, qué hace ese archivo:
> 1) Mantené mis fichas y notas actualizadas: nada importante se queda solo en el chat.
> 2) Si no estás seguro, preguntame antes de avanzar; no inventes ni adivines.
> 3) Hablame en castellano (voseo).
> 4) Antes de cambios grandes (crear/borrar/mover muchos archivos), mostrame el plan y esperá mi OK.
> 5) Nunca borres ni sobrescribas nada sin avisarme primero.
> 6) Cuando trabajes con mis documentos, citá de dónde sacaste cada cosa.
> 7) Al terminar, recordame actualizar el cuaderno.
> 8) Ordená los archivos así: lo que yo te doy en files/inputs, lo que vos generás en files/output.
> ```

Leelo. Si una regla no te cierra, escribile *"cambiá la regla X por…"*. Es tu base, la ajustás a tu gusto
y a tu oficio (ej.: *"si trabajo con contratos, citá siempre la cláusula"*).

**Antes de seguir:** abriste el `CLAUDE.md` y entendés qué dice cada regla. **Son tuyas: si no las
entendés, no te van a servir.**

### Paso 5 — Creá tu proyecto 0 (`00-aprendizaje`)

Es tu hub de conocimiento: ahí va todo lo que aprendas de acá en adelante.

> **[COPIAR AL CHAT]**
> ```
> Creá una subcarpeta llamada 00-aprendizaje. Adentro creá dos carpetas más, una dentro de otra:
> primero una llamada files, y adentro de files dos: inputs y output.
> Este es mi espacio de aprendizaje: acá voy a guardar lo que aprenda.
> ```

**Antes de seguir:** mirá la carpeta en el Explorador (o el Finder) y comprobá que quedó así, con `inputs`
y `output` **adentro** de `files`:

```
00-aprendizaje/
└── files/
    ├── inputs/
    └── output/
```

> **[DATO]** `00-aprendizaje` es también tu **buzón de dudas**: pedile que te cree ahí un `dudas.md` y
> escribí lo que no se entienda. Lo relés en el próximo módulo.

### Paso 6 — La convención de archivos: para qué son esos dos cajones

Dentro de **cada** proyecto (empezando por `00-aprendizaje`) vas a usar esa carpeta `files` con dos
cajones, para que **nunca se mezcle lo que vos traés con lo que la IA genera**:

- **`inputs`** = la rampa de **entrada**: lo que vos le entregás — PDFs, documentos, materiales de referencia.
- **`output`** = la rampa de **salida**: lo que la IA produce para vos — informes, resúmenes, entregables.
- **Tus notas y tu conocimiento propio** viven en la **raíz** del proyecto (tu cuaderno), **no** adentro de
  `files`.

Ordenás una vez y la IA siempre sabe dónde buscar y dónde dejar.

**Antes de seguir:** nada que hacer acá. Es la explicación de lo que creaste en el paso anterior.

### Paso 7 — Instalá tu Tutor Copiloto

Este es el bloque más largo del módulo, y es **un solo pegado**. Le da a tu asistente un **rol de tutor**
que arranca sabiendo qué hacer: lleva la bitácora de lo que hacés de verdad, te evalúa al cerrar cada
módulo y prepara tu archivo de avance.

**Leelo antes de pegarlo.** No es un texto mágico: son reglas escritas en castellano, y **las podés cambiar
cuando quieras** — es un archivo tuyo. Que puedas leerlas es justamente el punto.

> **[COPIAR AL CHAT]**
> ```
> Escribí exactamente este contenido en el archivo 00-aprendizaje/CLAUDE.md. No lo resumas ni lo
> reescribas: guardalo tal cual, desde la línea del título hasta el final.
>
> # Tu Tutor Copiloto — reglas de este proyecto (00-aprendizaje)
>
> Este proyecto es mi hub de aprendizaje de "Dirigir la IA". Acá, además de mi asistente de
> siempre, sos mi tutor. Estas reglas valen cuando trabajamos en este proyecto.
>
> ## Tu trabajo como tutor
>
> 1. Llevá una bitácora real. En bitacora.md (creála si no existe) anotá lo que pasa de verdad en
>    cada sesión: qué armé, qué me costó, qué se rompió y cómo lo resolví, qué te pregunté. No
>    inventes progreso: registrá lo que efectivamente hicimos. Esta bitácora es mi avance real.
>
> 2. Al cerrar cada módulo, evaluame. Cuando te diga "cerremos el módulo N" —o cuando veas que lo
>    terminé—:
>    - Leé el checklist de ese módulo, que voy a dejar guardado en files/inputs, y revisá mis
>      carpetas contra él, marcando cada punto con un tilde o con una advertencia.
>    - Tomame el repaso de ese módulo y corregímelo.
>    - Escribí avances-modulo-N.md en este proyecto, sintetizando la bitácora real + la evaluación
>      + el repaso: estado, qué logré, qué me costó, mis dudas y con qué quiero seguir.
>    - Mostrámelo y decime que lo copie y se lo mande a quien me lo mandó.
>
> 3. Saneá siempre el avance. Nada de datos sensibles ni secretos. Anonimizá nombres de terceros
>    (clientes, empresas, personas) manteniendo el sentido ("empresa de muebles", "Cliente A").
>    Guardá de qué se trata y en qué anda, no información privada.
>
> ## Cómo me acompañás (y cómo eso cambia)
>
> - Al principio, seguime de cerca. Si ves que terminé un módulo y no lo cerré, avisame y ofrecé
>   cerrarlo. Recordame el ritual de cierre. Sugerí el próximo paso. Preferí preguntar antes de
>   que me pierda.
> - A medida que agarre la mano, corréte. Cuando veas que cierro los módulos y dirijo sin que me
>   sigas, bajá a modo discreto: logueá en silencio y esperá a que te pida cerrar. No me trates de
>   principiante cuando ya no lo soy.
>
> ## Cuando el curso termine
>
> No te apagás: quedás como mi coach de aprendizaje. Seguí guardando lo que aprendo en este hub,
> tomame repasos si te los pido, y mantené mi conocimiento ordenado para reusarlo en mis otros
> proyectos.
> ```

**Qué cambia:** desde ahora, cuando trabajes en `00-aprendizaje`, tu asistente **arranca sabiendo** que es
tu tutor. No hay que re-explicárselo cada vez — está escrito en un archivo que relee. *(Es el método del
método aplicado a sí mismo: el rol vive en un archivo, no en un mensaje que se pierde.)*

**Antes de seguir:** existe `00-aprendizaje/CLAUDE.md` y **lo abriste para ver que dice lo que pegaste**.

### Paso 8 — Abrí tu base y miralá

> **[COPIAR AL CHAT]**
> ```
> Creá en la raíz de mi base un archivo inicio.html: una página que me muestre mi base
> cuando la abro.
>
> Qué tiene que mostrar:
> - Mis proyectos (uno por carpeta), y de cada uno: en qué anda y qué quedó pendiente.
> - Lo que tengo guardado en 00-aprendizaje.
> - Bien visible, la fecha y hora en que generaste esta página.
>
> Reglas técnicas (importantes, no las cambies):
> - UN SOLO archivo .html, autocontenido. El CSS y el JavaScript van adentro del archivo.
> - Tiene que abrirse con doble clic, sin servidor. Nada de fetch, ni módulos, ni build.
> - Sin internet: nada de fuentes, iconos, imágenes ni librerías que se bajen de afuera.
> - Poné <meta charset="utf-8"> para que los acentos se vean bien.
> - Que se lea cómodo y que no necesite explicación.
>
> Cuando termines, decime cómo abrirla.
> ```

Buscá el archivo `inicio.html` en tu carpeta y **hacele doble clic**. Se abre en tu navegador.

Y ahora **lo que vale el paso** — no te quedes mirándola:

> **[CLAVE] Pedile un cambio.** Por ejemplo: *"ponelos en tarjetas, y agregá en cada proyecto cuándo fue
> la última vez que lo toqué"*. Volvé a abrirla.

Esa página no existía hace cinco minutos. No la compraste ni la encargaste, está hecha a la medida de tu
trabajo, vive en tu disco — y **si querés que sea distinta, se lo pedís y cambia**.

> **[DATO] Si no abre o sale rara**, decíselo tal cual (*"la abrí y se ve mal"*) y la rehace. No hay nada
> que romper.

**Antes de seguir:** la abriste, **le pediste un cambio y volviste a abrirla**. El paso no es la página: es
la segunda versión.

---

## Lo que ya vas a poder pedirle (ejemplos genéricos)

Parado en tu carpeta, escribile cosas como:

- *"Pasá a una tabla ordenada esta lista suelta que tengo en este documento."*
- *"Resumime en qué quedó cada tema pendiente, para mi reunión de mañana."*
- *"Redactá un mail de seguimiento con mi tono para los contactos sin respuesta hace más de dos semanas."*
- *"Revisá mis notas y decime qué tareas quedaron sin próxima acción cargada."*

> Eso que hoy te lleva rato cruzando planillas, mails y memoria, lo hace mirando **un solo lugar ordenado**.

---

## Ritual de cierre (no te lo saltees)

Antes de cerrar cada sesión:

> **[COPIAR AL CHAT]**
> ```
> Antes de cerrar, actualizá mi cuaderno/notas con lo que hicimos hoy y lo que quedó pendiente.
> ```

Al día siguiente, abrí tu base y vas a verla **retomar sola**: relee tu ficha y tu cuaderno, y sigue en
qué andabas.

> **¿Por qué este ritual, en serio?** Porque Claude tiene un límite de cuánto puede "tener en la cabeza" a
> la vez (su *contexto*). Cuando se llena, la herramienta **auto-compacta**: resume la conversación y
> **descarta el detalle** — y lo descartado **no se puede recuperar**. Todo lo que vivía solo en el chat
> desaparece. Por eso el ritual **escribe primero a los archivos**: los archivos sobreviven la compactación;
> la memoria del chat, no. *(Vas a verme repetir esto un par de módulos más, hasta que sea automático.)*
>
> **[DATO]** Dato relacionado: si una charla se vuelve muy larga y la IA empieza a confundirse, escribí `/clear`
> para arrancar limpio. Como ya guardaste lo importante en archivos, no perdés nada.

### Y la tercera parte, que es la que casi nadie hace

Anotaste. Ahora **cerrá el chat y arrancá el próximo limpio.**

No es porque algo haya fallado — **es higiene, como guardar el archivo antes de apagar.** Acordate de lo
que vimos: todo lo que está a la vista se vuelve a procesar **en cada respuesta**. Una charla de tres horas
te está costando plata y calidad **aunque todavía no te hayas confundido**, porque en cada vuelta arrastra
todo lo anterior.

**El ciclo completo, y es el mismo siempre:**

```
abrís limpio  →  trabajás una tanda  →  anotás en el cuaderno  →  cerrás
```

Y no perdés nada, porque **lo que importaba ya está escrito en tus archivos**: al abrir de nuevo, relee tu
ficha y tu cuaderno y sigue donde quedaste. Eso es exactamente lo que probaste hoy.

> **[CLAVE] Cerrá seguido, no cuando explote.** Una tanda de trabajo = un chat. Cambiás de tema, cerrás.
> Volvés mañana, chat nuevo. Si te da cosa cerrar, es señal de que hay algo importante que **todavía no
> anotaste** — anotalo, y ahí cerrar deja de dar cosa.

---

## Lo que te llevás

- ✓ **Claude Code instalado y abierto** en tu sistema operativo.
- ✓ Tu **carpeta base** creada, con su `CLAUDE.md` de reglas que te recibe al entrar.
- ✓ Tu **`perfil.md`** cargado por vos mismo/a, con la técnica de "entrevistame".
- ✓ Tu **proyecto 0 `00-aprendizaje`** listo, con la convención de entrada y salida.
- ✓ Tu **Tutor Copiloto** instalado como `00-aprendizaje/CLAUDE.md`, y **leído** antes de instalarlo.
- ✓ Tu **`inicio.html`**: tu base, visible de un vistazo — y cambiada pidiéndolo.
- ✓ El **ritual de cierre** entendido: nada importante queda solo en el chat.

**Y ahora el experimento que vale el módulo entero — hacelo a propósito, no esperes a mañana:** una vez
que guardaste todo, **cerrá esta conversación y abrí una NUEVA**. Volvé a abrir tu carpeta base y mirá
cómo te recibe con tu ficha y tus reglas ya cargadas.

> **Cerraste y no perdiste nada — y encima arrancás más limpio**, porque el chat viejo venía cargado y la
> conversación nueva relee de tus archivos solo lo que importa. Eso que sentís ahí es la idea entera del
> método: **tu conocimiento no vive en la charla, que se borra. Vive en tus archivos.**

---

## [PARA TU BASE] Y el último prompt: cerrá el módulo

Este es el otro bloque largo, y es el único que te pido que pegues entero. Hace dos cosas: **deja el
módulo guardado en tu base** —para que tu tutor tenga contra qué evaluarte— y **cierra**.

> **[COPIAR AL CHAT]**
> ```
> Terminé el módulo 1. Hacé tres cosas, en este orden:
>
> 1) Guardá en 00-aprendizaje/files/inputs/modulo-1.md un archivo con este checklist, tal cual
>    te lo paso:
>
>    - Claude Code instalado y abierto
>    - Mi carpeta base creada, y la IA parada adentro
>    - Mi ficha perfil.md cargada por entrevista
>    - Mis reglas escritas en el CLAUDE.md de la carpeta base
>    - El proyecto 00-aprendizaje creado, con files/inputs y files/output adentro
>    - El Tutor Copiloto instalado como CLAUDE.md de 00-aprendizaje
>    - inicio.html generado, abierto, y cambiado una vez pidiéndoselo
>    - Probé cerrar la conversación y abrir una nueva, y mi base me recibió con todo cargado
>
> 2) Revisá mis carpetas contra ese checklist y marcá cada punto con un tilde o con una
>    advertencia, diciendo qué falta en los que no estén.
>
> 3) Tomame el repaso: son cuatro preguntas y tengo las opciones acá, en el material. Hacémelas
>    de a una, en este orden, esperá que te diga la letra que elijo, y corregime explicando por qué:
>    1. ¿Qué es Claude Code, comparado con el chat de la web?
>    2. ¿Dónde viven las reglas de cómo querés que la IA trabaje siempre?
>    3. ¿Qué es 00-aprendizaje?
>    4. ¿Por qué corrés el ritual de cierre antes de terminar?
>
> Con todo eso escribí avances-modulo-1.md como te configuré, mostrámelo y decime que se lo
> mande a quien me lo mandó.
> ```

**La mecánica clave que va a evaluar** (la prueba del "wow"): que hayas **cerrado la conversación y
abierto una nueva**, y que al volver a tu base te reciba con todo cargado. Si no lo probaste, hacelo ahora
— es lo único de este módulo que no se puede contar, hay que sentirlo.

### Las opciones del repaso

Cuando te haga cada pregunta, mirá acá y **decile la letra** que elegís.

**1)** a) Un programa distinto que hay que aprender a programar. · b) El mismo Claude, pero parado dentro
de una carpeta tuya, que ve y crea archivos. · c) Una versión más lenta del chat, sin ninguna ventaja.

**2)** a) En el `CLAUDE.md` de tu carpeta madre. · b) Se las repetís en el chat cada vez que entrás. ·
c) En un mail que te mandás a vos mismo/a.

**3)** a) Un cajón donde van adentro todos tus otros proyectos. · b) Un proyecto 0, hermano de tus
proyectos reales, donde guardás lo que aprendés. · c) Una carpeta temporal que se borra al terminar.

**4)** a) Por prolijidad, pero da igual si no lo hacés. · b) Porque cuando el contexto se llena la IA
auto-compacta y descarta detalle que no se recupera; los archivos sobreviven, el chat no. · c) Para que la
IA trabaje más rápido la próxima vez.

---

## Lo último, y es lo que hace que exista un módulo 2

Cuando termine de corregirte, **va a generar tu `avances-modulo-1.md`**. Ese archivo es el que mandás:
tiene qué armaste, qué te costó, cómo te fue en el repaso y tus dudas.

**Copialo y mandalo.** Con eso se escribe el módulo 2 apuntado a tu caso — y si algo no salió, contalo tal
cual salió: eso vale más que si sale todo perfecto.

---

*Este primer módulo va bien detallado a propósito —al arranque conviene tener la mano agarrada—. A medida
que avances, los módulos van a ser más cortos y directos: ya vas a tener la mecánica incorporada. Los
próximos suman tu sistema de proyectos, darle tus documentos y encadenar tareas largas. Se guarda tu avance
para no arrancar nunca de cero.*