Tu primer agente de AI

Un agente no es un chatbot

Un LLM "pelado" (ChatGPT en un navegador, Claude.ai) es un modelo que recibe texto y devuelve texto. Es una conversación. Cuando termina la respuesta, no hizo nada en el mundo real — solo te habló.

Un agente es un LLM más la capacidad de tomar acciones: leer tus archivos, escribir nuevos, ejecutar comandos, llamar a APIs. No sólo te contesta — hace cosas. Le pedís algo en español y va iterando hasta resolverlo.

Un coding agent es un agente con foco en software: vive en tu máquina, tiene acceso a tu filesystem, lee tu código, escribe archivos, corre tests, commitea a Git. En la hackathon vamos a usar Claude Code — no por ser el único, sino por uniformidad en pantalla y madurez actual.

Las 4 tools básicas que lo desmitifican

Esta es la idea que te saca la magia de encima y te deja ver qué está pasando. Un coding agent no hace magia — en definitiva, tipea comandos en tu terminal usando 4 herramientas básicas que todos los agentes comparten (Claude Code, Codex, Gemini CLI, OpenCode):

Ejemplo: "analizá este CSV y generame un reporte"

Por debajo, el agente va a hacer esto exactamente (lo vas a ver en pantalla mientras lo hace):

1. Read → abre el CSV para ver su estructura.
2. Grep → si hay otros archivos relacionados, los busca.
3. Write → genera un script de Python en scripts/reporte.py.
4. Bash → ejecuta uv run scripts/reporte.py.
5. Read → lee el output para verificar que salió bien.
6. Si algo falló, Edit sobre el script e itera.

Los mismos pasos que daría un humano — solo que más rápido, sin parar, y sin olvidarse de los detalles. El agente usa las mismas herramientas que vos aprendiste a la mañana. Por eso la terminal (Bloque 1) y los CLIs (Bloque 2) son la base de todo lo de la tarde.

Debajo sigue siendo un LLM autocompletando

Este es el concepto que cierra todo lo anterior. Un LLM "pelado" es, en el fondo, un predictor de texto: le pasás un contexto (una secuencia de tokens) y devuelve la continuación más probable. Cuando usás Claude.ai o ChatGPT en el navegador, estás viendo exactamente eso — input, autocompletar, output.

En un agente eso no cambia. Lo único nuevo es un loop alrededor del modelo. Y quien coordina ese loop no es el LLM — es un programa (Claude Code, Codex, Gemini CLI…) que corre en tu máquina y hace de director de orquesta:

1. Arranca un contexto inicial: instrucciones del sistema + descripción de las tools disponibles + tu prompt.
2. Manda ese contexto al LLM. El LLM autocompleta — y si decide que necesita una tool, su output es un "tool call" (ej. Read("ventas.csv")).
3. El framework (no el LLM) ejecuta esa tool en tu máquina y obtiene el resultado.
4. El resultado se pega al final del contexto.
5. Se le manda al LLM el contexto entero de nuevo — system prompt, tu pedido, tool call anterior, resultado, todo — y el LLM vuelve a autocompletar.
6. Repetir hasta que el LLM decida "ya no necesito más tools" y devuelva una respuesta final.

El insight clave: el LLM no tiene memoria entre turnos. Lo que parece memoria es que el framework le está reenviando el stack completo — y creciente — en cada vuelta. Todo lo que pasó vuelve a estar frente al modelo cada vez que autocompleta.

Cada caja gris es exactamente lo que se le manda al LLM en ese turno. Fijate cómo la caja crece — el LLM no recordó el turno anterior, lo está volviendo a ver completo.

Esto también explica por qué el contexto importa tanto — si se llena de ruido o pierde información clave, el LLM autocompleta peor. Es la idea que retomamos en profundidad en el Bloque 7 · Context management.

Claude Code no es el único

A abril 2026 estos son los 4 grandes — todos corren en la terminal con una lógica muy parecida. Los comandos y el concepto se transfieren casi 1:1 entre todos.

Por qué Claude Code para la hackathon: uniformidad en pantalla (todos vemos lo mismo), la cuenta corporativa de Growketing ya está habilitada, y el comportamiento es predecible para guiar a un grupo. Pero si mañana querés probar Codex o Gemini para tu día a día, no tenés que volver a aprender — los reflejos son transferibles.

Tu primer agente corriendo en tu Mac

Asumiendo que tenés npm del Bloque 2 y tu .env con ANTHROPIC_API_KEY, son 2 comandos.

cd ~/Desktop/hackathon-prueba     # el proyecto del Bloque 3
npx @anthropic-ai/claude-code     # primera vez: descarga y arranca
# en la terminal se abre el agente — pedile algo en español y mirá qué hace

Cuando arranca, Claude Code "ve" la carpeta desde la que lo invocaste. Si corriste npx … desde hackathon-prueba, el agente ya sabe dónde está tu CSV, tu script y tu README. Y — esto es clave — ese agente es distinto del que vas a tener en otro proyecto. Lo vemos abajo.

La primera consigna para probarlo

No le pidas algo trivial como "hola". Pedile algo que requiera usar las 4 tools:

Leé datos/clientes.csv y modificá scripts/analisis.py para que también
imprima el promedio de agentes por área. Corré el script al final para
verificar que funciona.

Mientras trabaja, vas a ver que abre archivos, escribe código, corre el script, lee el output, y si algo falla, corrige. Eso son las 4 tools en acción.

Cada directorio es un agente distinto

Esta es la frase madre que ordena todo lo que viene después (CLAUDE.md, skills, MCPs): cada carpeta donde abrís Claude Code es un agente propio. Tiene sus permisos aprobados, su memoria de decisiones, su CLAUDE.md, sus skills de repo. Si mañana abrís Claude Code en otra carpeta, es otro agente — arranca de cero sobre ese proyecto, aunque por debajo sea el mismo Claude Code.

Esto sigue exactamente la convención de dotdirs que ya viste en el Bloque 1: archivos y carpetas que empiezan con . son configuración. Claude Code vive en dos capas:

El mismo patrón que ya conocés de otras herramientas: ~/.gitconfig (global, tu identidad de Git) vs .git/ (específico de este repo). Mismo principio.

El "manual" que le dejás al agente sobre tu proyecto

Ya sabés que este agente es el agente de esta carpeta. CLAUDE.md es el archivo donde le dejás, a ese agente puntual, qué tipo de código es el tuyo, qué convenciones usás, y qué decisiones ya tomaste. Vive en la raíz del proyecto y el agente lo carga automáticamente al arrancar — es su "manual de bienvenida" y lo que lo vuelve este agente y no uno genérico.

# Hackathon Prueba

## Stack
- Python 3.12 con uv
- CSVs crudos en `datos/`, scripts en `scripts/`

## Convenciones
- Los scripts leen variables de entorno desde `.env` (ya cargado).
- Nada de pandas — usamos el módulo `csv` stdlib para mantenerlo simple.
- Los resultados se imprimen a pantalla; no escribimos archivos de output salvo que se pida.

## Qué no hacer
- No instales dependencias nuevas sin preguntar.
- No toques `.env` — está en `.gitignore` por algo.

Después de agregar un CLAUDE.md, cerrá y volvé a abrir el agente. Vas a notar que respeta más tus preferencias sin que se las tengas que repetir.

Enseñarle tareas repetibles (lo vemos a fondo en B5)

Un concepto que va a aparecer todo el día: las Skills. Son carpetas con instrucciones + scripts que le enseñan al agente a hacer una tarea específica de forma consistente. Ejemplos:

• Skill "Reporte PPC Growketing" — sabe qué columnas mirar, con qué brand guidelines, y qué formato usar para el PDF.
• Skill "Onboarding de empleado" — conoce el checklist interno y genera la documentación lista.
• Skills pre-hechas de fábrica: Excel, Word, PowerPoint, PDF — el agente las carga sola cuando detecta que las necesita.

En el Bloque 5 lo vemos en serio. Por ahora guardá la idea: Skill = "así se hace X tarea" (procedimiento). El gancho con MCP viene ahí también.

Qué es un agente de AI — 7 min

Si hay un solo video del pre-work que mirar para este bloque, que sea éste.

Si querés darle una vuelta antes del viernes

Los 3 coding agents del ecosistema se instalan parecido — no hace falta hacerlo ahora, pero si te pica la curiosidad:

# Claude Code (Anthropic) — el que vamos a usar
npx @anthropic-ai/claude-code

# Codex CLI (OpenAI)
npm install -g @openai/codex

# Gemini CLI (Google) — tiene tier gratis
npx @google/gemini-cli

Los tres te piden credenciales al primer uso. No te preocupes por configurarlas ahora — lo vemos juntos el viernes. Solo probá que corran.

Para los que van rápido

• Pedile al agente que genere un script más complejo: un gráfico con matplotlib, leer múltiples CSVs, o formatear un reporte en Markdown.
• Probá plan mode — antes de pedirle que haga algo grande, pedile que proponga el plan primero. Revisás, ajustás, y después que lo ejecute.
• Creá un CLAUDE.md con las convenciones de tu área (ej. "todos los reportes PPC usan esta estructura"). Después pedí algo y mirá si lo respeta.
• Explorá los slash commands: /help, /compact (comprime la conversación), /model (cambiar entre Opus/Sonnet/Haiku), /clear.
• Pedile al agente que se explique a sí mismo: "¿por qué elegiste este approach? ¿qué alternativas hay?". A veces aparece una mejor.

¿Lo hiciste y lo entendés?

Al final del bloque tenés que haber hecho al menos una modificación concreta con el agente sobre tu proyecto. Eso es lo mínimo que vas a mostrar en el Milestone de las 15:00.

Lecturas y cursos