IA aplicada

Episodio 02 · Claude Code

De la ventana de chat a un agente local sobre tus datos

Un modelo en el navegador está ciego: no ve tus columnas, ni los tipos, ni los faltantes, y no puede correr un summary(). Claude Code es el mismo modelo, pero operando dentro de tu máquina — lee el error real de la terminal, ejecuta tu código y verifica el resultado. En este episodio lo usamos para hacer EDA y descriptivas sobre microdatos confidenciales, con el rigor que tu trabajo exige.

Nivel
Intermedio
Modalidad
Teoría + práctica en vivo
Stack del ejemplo
R · user_base.rds
Requisitos
Claude Code (Pro/Max) + un repo

Del chat al agente

Partes 1–2
1

Del navegador al agente local

Por qué un agente que ve tu proyecto y ejecuta cambia el flujo de trabajo, y cómo arrancar tu primera sesión.

  • El modelo del navegador está ciego. No tiene visibilidad de tu estructura de directorios, ignora qué versiones de paquetes tienes instaladas y —lo más crítico— no puede probar si el código que propone corre. Pegar errores en rojo y cruzar los dedos es el ciclo viejo.
  • Claude Code es un agente local. Lee el error directo de la terminal, inspecciona los archivos, ejecuta tu script y verifica la salida. El mecanismo es un bucle: planificar → ejecutar localmente → observar resultados → corregir, hasta que el código corre.
  • Se instala donde trabajas. macOS, Linux y —ojo con un mito frecuente— Windows de forma nativa (PowerShell o CMD). WSL es opcional, útil si quieres toolchains de Linux o el sandbox; no es un requisito.
  • Plan mode es tu hábito de control. Es un modo de solo lectura: Claude explora y te presenta un plan, sin escribir nada hasta que apruebas. Para quien le teme a soltar un agente sobre sus datos, es la red de seguridad más barata que existe.
Aplicación en vivo

Abre la terminal en la carpeta de tu proyecto y corre claude. Genera el manifiesto base con /init y pídele una mirada estructural: «describe el árbol del repo y para qué sirve cada carpeta» — todavía sin abrir los datos crudos.

Aplicación en vivo

Entra en plan mode con /plan antes de cualquier tarea sobre la base. Verás que Claude propone los pasos y espera tu visto bueno. Adóptalo como el arranque por defecto del resto del episodio.

2

Cabina de mando: comandos y ventana de contexto

Para tu audiencia, controlar el contexto es controlar el costo y la fiabilidad. Aquí está el tablero.

  • La superficie de comandos. Escribe / para ver todo; un comando solo se reconoce al inicio del mensaje y lo que sigue son sus argumentos. /help lista lo disponible.
  • La ventana de contexto es un recurso finito. Todo consume tokens: el system prompt, el CLAUDE.md, cada salida de herramienta, los archivos que lee. Cuando se llena, la adherencia baja y el costo sube (re-lee el historial). Por eso se vigila y se administra.
  • El dial de esfuerzo (/effort): low → medium → high → xhigh → max, más ultracode (propio de Claude Code: combina razonamiento xhigh con orquestación de workflows). Para limpiar nombres de variables o descriptivas básicas, low/medium basta.
  • El bucle de aprobación (permission modes): default pregunta antes de actuar; acceptEdits acepta ediciones de archivos; plan es solo lectura; bypassPermissions salta los permisos (úsalo con cuidado). Nada se escribe a disco sin tu OK en el modo por defecto.
Aplicación en vivo · vigilar el contexto

Tras perfilar muchas columnas, corre /context: muestra en una grilla a color qué está llenando la ventana y avisa de saturación. Luego /compact lo resume para liberar espacio, o /clear arranca tarea nueva conservando la memoria del proyecto. Para una pregunta al margen que no infle el historial, /btw.

Aplicación en vivo · costo y recuperación

Revisa gasto y límites del plan con /usage (alias /cost). Y si Claude se desvía, /diff te muestra los cambios antes de quedártelos, y /rewind devuelve código y/o conversación a un punto previo.

Gobernar al agente

Partes 3–4
3

Microdatos confidenciales: la barrera de acceso

Tu caso real (SISBEN, CSJ, registros fiscales): cómo bloquear de verdad qué puede leer Claude, y por qué el archivo "ignore" no alcanza.

  • Los archivos "ignore" no son una barrera de acceso. .claudeignore y .gitignore reducen la inclusión automática al contexto y a las búsquedas, pero no impiden una lectura si la pides directamente. Construir tu privacidad sobre ellos es un error documentado.
  • El mecanismo real: permissions.deny en .claude/settings.json. Los archivos que matchean quedan fuera del descubrimiento y la búsqueda, y las lecturas sobre ellos se deniegan. Reemplaza el viejo ignorePatterns; la sintaxis es estilo gitignore.
  • Un solo deny no basta — piensa en capas. Una regla Read(...) bloquea la herramienta Read, pero el modelo todavía podría leer por Bash. Muro real = regla Read(...) + negar el equivalente en Bash + sandbox (macOS/Linux), que cierra ese escape a nivel de sistema operativo.
  • El patrón más fuerte: ejecuta local, devuelve agregados. Claude escribe el código, corre contra los datos en tu máquina y solo vuelve una tabla agregada. Las filas confidenciales nunca van al modelo ni a la nube. Es el mismo principio que la calculadora prohibida (Parte 7): el modelo orquesta, la máquina toca los datos.
  • Siguiente nivel (opcional): MCP a una base local. En vez de cargar un .rds gigante al contexto, conectas Claude a una base local (DuckDB / Postgres) por MCP: él escribe el SQL, la base lo ejecuta y devuelve el agregado. Ideal para descriptivas sobre datos sensibles, sin mover una sola fila.
Mito

«Pongo mis .rds en .claudeignore y Claude no los lee.»

Realidad

Se probó que Claude lee archivos listados en .claudeignore. El bloqueo real es permissions.deny (+ Bash + sandbox).

.claude/settings.json# Bloquea la lectura de las bases del proyecto { "permissions": { "deny": [ "Read(./output/datasets/*.rds)", "Read(./data/**)", "Read(./**/*.parquet)" ] } }
Aplicación en vivo · mini-experimento de seguridad

Escribe el deny de arriba, reinicia la sesión y pídele a Claude que lea el .rds. Velo rechazado. Luego conversen el hueco de Bash y, en mac/Linux, activa /sandbox para cerrarlo. Audita las reglas vigentes con /permissions.

4

Memoria: CLAUDE.md y auto-memory

Los dos sistemas de memoria de Claude Code, qué garantiza cada uno, y cómo escribir tu manifiesto de EDA.

  • CLAUDE.md — lo escribes tú. Se carga completo en cada sesión, sin importar el largo. Las ~200 líneas son una recomendación de adherencia, no un corte: archivos más largos consumen más contexto y se siguen peor, pero no se truncan.
  • Es una guía, no una constitución vinculante. Claude lo lee y suele seguirlo, pero no hay garantía de cumplimiento estricto. Para bloquear algo pase lo que pase —que jamás cambie la semilla, que no borre un .rds— se usan hooks o permisos, no el manifiesto.
  • Auto-memory — la escribe Claude. Una bitácora autónoma (MEMORY.md) donde anota resoluciones técnicas y convenciones que descubre. Aquí sí vive un corte real: se cargan las primeras 200 líneas o 25 KB; los archivos por tema se leen bajo demanda. Gestiónala con /memory.
  • Directivas concretas y verificables. Nada de «limpia los datos». Sí: semilla fija 20260625; reportar missingness, nunca borrar en silencio; figuras en ggplot a 300 dpi; tablas en LaTeX con tu house style.
CLAUDE.md — extracto (convenciones de EDA)# Datos & reproducibilidad - Semilla aleatoria fija: set.seed(20260625). - La missingness se REPORTA, nunca se borra en silencio. - Ingreso: ingresos==0 e ingresos_hogar==0 son CENTINELA (subreporte de SISBEN, ~59% y ~42%) → describir distribuciones, no medias. - Sexo: fcoalesce(mujer_obs, mujer_imp); nota al pie: "observado en SISBEN o, si no, inferido del primer nombre". # Salidas - Figuras: ggplot, tema minimalista, PNG a 300 dpi. - Tablas: tabular de LaTeX (dobles reglas, filas auxiliares en itálica).
Aplicación en vivo · guiar vs. garantizar

Escribe tu CLAUDE.md con esas convenciones. Luego añade un hook PreToolUse que bloquee de verdad borrar o sobrescribir el .rds fuente — y comprueba la diferencia: el manifiesto orienta, el hook impide.

.claude/settings.json — hook que protege el dato fuente{ "hooks": { "PreToolUse": [{ "matcher": "Bash", "hooks": [{ "type": "command", "command": "./.claude/guard-datasets.sh" }] }] } } # guard-datasets.sh sale con código 2 si el comando intenta rm/mv/> sobre *.rds

Trabajar en vivo

Partes 5–6
5

El bucle de corrección, en vivo

Dejar que el agente diagnostique y arregle una anomalía real de EDA — y auditar que no rompió la metodología.

  • Cómo trabaja el bucle. Lee la anomalía o el error, inspecciona (p. ej. abre la matriz de correlaciones o un str()), corrige y re-ejecuta — sin detenerse hasta que corre.
  • El riesgo metodológico. Un agente que «solo quiere que deje de dar error» puede tirar NA en silencio, forzar mal un tipo, o tratar el cero-centinela como dato real. En economía empírica, cambiar cómo se tratan los atípicos o los faltantes puede cambiar la conclusión. La confianza ciega no es metodología.
  • La reproducibilidad no viene del agente. El agente es no-determinista: corre dos veces y escribe código distinto. Lo reproducible es el artefacto — el script versionado, las semillas fijas en el código y el historial de git. Claude es el colaborador que escribe el artefacto; git es tu red de seguridad y tu bitácora auditable.
Aplicación en vivo

Provoca un momento real: un summary() con la media de ingresos arrastrada por ceros y edad con valores imposibles, o un join que infla filas. Deja que lo diagnostique y arregle. Después audita el diff: ¿borró filas? ¿recodificó faltantes como cero? ¿tocó la semilla? Si algo no cuadra, /rewind.

6

Escalar descriptivas sin perder el control

Cuándo conviene un subagente, qué aísla de verdad, y qué features tienen letra chica para tu plan.

  • El uso canónico de un subagente es aislar salida voluminosa: perfilar 80 columnas genera muchísimo texto que no quieres en tu conversación principal. El subagente lo hace en su propia ventana y te devuelve solo el resumen.
  • El aislamiento es de contexto, no de archivos. Por defecto los subagentes comparten el mismo directorio de trabajo; lo que está aislado es la ventana de contexto. El aislamiento por git worktree existe pero es opt-in (isolation: worktree); sin él, varios agentes en paralelo sí pueden pisarse archivos.
  • "Cientos de agentes" tiene nombre y letra chica. Es dynamic workflows: está en research preview y solo en planes Enterprise, Team y Max. No lo asumas como capacidad universal.
  • Defensas contra el bucle infinito. Restringe herramientas con tools/disallowedTools, vigila con /context, poda con /compact, y mantén el esfuerzo bajo para tareas repetitivas.
Aplicación en vivo

Pide un subagente que perfile todas las columnas de user_base.rds (tipo, % NA, rango, cardinalidad) y devuelva solo la tabla resumen — no el detalle columna por columna. Limita sus herramientas a lectura y ejecución, y revisa el consumo con /context antes y después.

Rigor y reutilización

Partes 7–8
7

La calculadora prohibida

La trampa más letal del paradigma: pedirle al modelo que calcule. Nunca lo hagas.

  • El modelo no calcula. Por avanzado que sea —Opus 4.8, lanzado el 28 de mayo de 2026— sigue siendo un motor predictivo de lenguaje: estima probabilidades de palabras, no hace matemáticas dentro de su red neuronal.
  • La alucinación numérica. Si en el chat le pides «¿cuál es la mediana del ingreso del hogar?», puede devolver un número plausible pero inventado, envuelto en lenguaje académico impecable. En EDA es peor, porque una media o un % «se sienten» fáciles y uno se tienta.
  • La regla operativa: escribir → ejecutar → leer. El modelo programa el cálculo en un script local (R/Python), lo ejecuta en la terminal forzando al intérprete a hacer el cálculo duro, y su única responsabilidad luego es leer el resultado exportado y reportarlo. El trabajo pesado se delega siempre al software estadístico.
Mal · el chat como calculadora

«Dame la mediana de ingresos_hogar y el % de NA.» → número inventado.

Bien · puente al intérprete

«Escribe y ejecuta el script que calcule mediana, DE y % NA por grupo treated, exporta a CSV, y reporta lo exportado.»

Aplicación en vivo

Haz el contraste tú mismo: primero pídele la mediana «de memoria» en el chat; luego pídele el patrón escribir-ejecutar-leer para una tabla de descriptivas (media, DE, cuantiles, % NA, por grupo treated). Compara, y nota cuál puedes defender ante un referee.

8

Réplica reproducible y Skills

Empaquetar el EDA para que corra en cualquier máquina, y capturar tus convenciones como capacidades reutilizables.

  • Paquete de réplica. Claude escanea el directorio y detecta dependencias frágiles —rutas absolutas a tu escritorio—, las convierte en rutas relativas, arma un entorno reproducible y escribe un script maestro que va del microdato crudo al reporte con un solo comando.
  • Skills ≠ subagentes. Una Skill es una capacidad reutilizable (instrucciones + scripts) que carga bajo demanda en el contexto principal de la conversación — no es un subagente aislado. Le das a Claude un procedimiento que sabe invocar cuando aplica.
  • Tus comandos propios son Skills. Lo que repites —generar un codebook, armar una tabla con tu house style— se captura una vez como Skill y queda disponible como comando en cada sesión y para tu equipo (vía control de versiones).
Aplicación en vivo · reporte reproducible

Pídele armar un reporte de EDA reproducible: del user_base.rds crudo a un PDF/HTML de descriptivas con figuras ggplot a 300 dpi, ejecutable con un script maestro. Que detecte y corrija cualquier ruta absoluta.

Aplicación en vivo · una Skill

Crea una Skill «generador de codebook» (o «tabla de descriptivas con house style»: dobles reglas, filas auxiliares en itálica, etiquetas en inglés). Invócala sobre la base y verifica que la salida sale consistente sin re-explicar el formato.

Tu sesión de práctica, de principio a fin

Las ocho aplicaciones, en orden. Hazlas sobre tu propio repo; el agente trabaja localmente y tus microdatos no salen de tu máquina.

01
Arranca y planifica

claude + /init + /plan: mirada estructural y plan antes de tocar nada.

02
Maneja la cabina

/context, /compact, /clear, /usage, /rewind, /effort.

03
Cierra el acceso

permissions.deny sobre tus .rds, intenta leerlo, falla, y activa /sandbox.

04
Escribe la memoria

CLAUDE.md con convenciones de EDA + un hook que protege el dato fuente.

05
Corrige y audita

Arregla una anomalía real y revisa el diff: ni filas borradas ni NA recodificados.

06
Escala con control

Un subagente perfila todas las columnas y devuelve solo el resumen.

07
Nunca calculadora

El patrón escribir-ejecutar-leer para tu tabla de descriptivas.

08
Empaqueta y reutiliza

Reporte reproducible (crudo → PDF) + una Skill con tu house style.