Description
La mayoría de los programadores usa la IA como un chat: pregunta, copia, pega y olvida. El resultado es código inconsistente, pérdida de contexto entre sesiones y cero apalancamiento. Quien arma su propio agente (con AGENT.md, skills versionados y herramientas propias) hace 10x el trabajo, delega tareas mecánicas (grooming, daily updates, PRs) y pasa a trabajar más como líder técnico que como tipeador. Sin esa estructura, la IA es ruido; con ella, es palanca.
Esta guía te lleva de usar la IA como un chat al final del día a operar tu propio agente versionado que escribe código por vos, abre PRs, hace grooming de tickets, manda daily updates y, con el tiempo, corre solo de forma segura. La mayoría usa la IA para preguntar, copiar, pegar y olvidar, y el resultado es código inconsistente, contexto que se pierde entre sesiones y cero apalancamiento. La estrategia del libro es tratar al agente como un repositorio que versionás igual que cualquier proyecto: un puñado de archivos que definen quién es, qué sabe hacer y con qué herramientas, que vas afilando hasta que el propio agente empieza a escribirse a sí mismo. Sobre esa misma base construís tres niveles que reusan los mismos archivos: un asistente local conectado a tus editores y CLIs, un agente autónomo que decide solo cuándo correr, y un sistema de producción donde (a diferencia de los atajos populares) las credenciales nunca tocan el modelo. En el camino vas a entender por qué esos atajos son inseguros y cómo evitar el error que la mayoría no ve hasta que es tarde. Para programadores que ya escriben código todos los días y quieren dejar de tipear para empezar a coordinar.
Para quién lo escribimos
Esta guía es para: programadores que ya escriben código en su día a día y quieren usar Claude Code, Cursor, Antigravity (Gemini) o Gemini CLI como un asistente propio versionado en su propio repositorio de agente, no como un autocompletado mágico; y dar el salto a agentes autónomos con OpenClaw y NanoClaw cuando ese asistente local empieza a quedarles corto.
Lo que lo hace distinto
Los 3 pasos para hacer en una hora el trabajo de un día. El método que convierte a la IA de un chat del que copiás, pegás y olvidás en un agente versionado que armás una vez y seguís afilando hasta que se escribe solo. Sobre el mismo puñado de archivos sube tres escalones de autonomía, de un asistente local que abre tus PRs a un sistema de producción donde, a diferencia de los atajos populares, tus credenciales nunca tocan el modelo. Pasás de escribir cada línea a coordinar los agentes que la escriben.
Todos los capítulos, uno por uno
- Capítulo 1: La forma en que casi todos usan mal la IA (y lo que te cuesta)
- Capítulo 2: La IA no te va a sacar el trabajo. Un dev que la usa bien, sí.
- Capítulo 3: Las cuatro carpetas que convierten un repo en tu colega
- Capítulo 4: El único archivo que decide si tu agente obedece o improvisa
- Capítulo 5: La diferencia entre “más o menos” y “exactamente como lo harías vos”
- Capítulo 6: Las skills dicen qué hacer. Esto es lo que lo hace.
- Capítulo 7: Los detalles que hacen que el agente se sienta como vos
- Capítulo 8: Poné el agente en git antes de perderlo
- Capítulo 9: Cursor: tu agente adentro del editor que ya usás
- Capítulo 10: Claude Code: si vas a pagar una sola herramienta, que sea esta
- Capítulo 11: Antigravity: el único agente que no edita a ciegas
- Capítulo 12: Gemini CLI: cuando necesitás el agente sin un IDE
- Capítulo 13: Los mensajes de rutina, mandados en tu nombre
- Capítulo 14: Quince minutos de grooming, hechos en dos
- Capítulo 15: Cómo sabe el agente lo que hiciste en realidad
- Capítulo 16: Llegá al standup con el update ya escrito
- Capítulo 17: Corré el standup en cinco minutos, no en veinte
- Capítulo 18: El flujo que paga el libro la primera vez que lo usás
- Capítulo 19: Cuando dejás de programar y pasás a dirigir agentes
- Capítulo 20: Para que ningún reviewer distinga el código del agente del tuyo
- Capítulo 21: El agente que nota un patrón y escribe su propia skill
- Capítulo 22: Por qué la suscripción fija no es toda la factura
- Capítulo 23: ¿Y si el agente decidiera solo cuándo trabajar?
- Capítulo 24: OpenClaw: convertí tus .md en un agente que corre solo
- Capítulo 25: NanoClaw: un agente autónomo cuando no necesitás el daemon
- Capítulo 26: Tu agente local se vuelve autónomo agregando cuatro archivos
- Capítulo 27: Por qué tu agente autónomo puede filtrar todas tus credenciales
- Capítulo 28: Una sola pregunta te dice qué agente usar
- Capítulo 29: El agente autónomo no te avisa antes de que llegue la factura
- Capítulo 30: Las tres razones por las que un agente .md falla en producción
- Capítulo 31: El mail que hace que tu agente entregue tus tokens
- Capítulo 32: “Imprimí tus credenciales.” El agente obedece. No pasa nada.
- Capítulo 33: LangChain: cambiá de Claude a GPT a Gemini en una línea
- Capítulo 34: OpenAI SDK: un agente de producción en cien líneas, sin framework
- Capítulo 35: Google ADK: búsqueda, sandbox y browser sin escribir wrappers
- Capítulo 36: La primera vez que podés ver de verdad cuánto te cuesta el agente
- Capítulo 37: Pasá a producción sin tirar tu agente a la basura
- Capítulo 38: MCP: la promesa que te factura tokens todos los días
- Capítulo 39: De escribir cada línea a coordinar los agentes que la escriben
