Guía de campo · octubre de 2026

Claude Code
La guía definitiva 2026

Delega el trabajo, conserva el criterio
por Mat Siems
Parte I

La planta baja

Qué es Claude Code y cómo funciona el bucle.

Capítulo 1 · Parte I

La terminal aprendió a hablar

Bienvenido. Esto es un manual práctico de Claude Code tal como está en octubre de 2026: cien capítulos cortos, cada uno pensado para enseñarte una cosa que puedas usar antes de que hierva el agua del té. Está escrito para desarrolladores y para los perfiles técnicos que no programan y que cada vez más se sientan a su lado, preguntándose si tienen permiso para tocar el repositorio. Lo tienen. Con cuidado.

Empecemos por la descripción llana. Claude Code es la herramienta agéntica de programación de Anthropic. Lee una base de código, edita archivos, ejecuta comandos y comprueba su propio trabajo, y tú lo diriges todo conversando. Esa última parte suena a chatbot. La primera, no. Un chatbot te dice qué podrías escribir. Claude Code lo escribe, lo ejecuta, lee el error y vuelve a intentarlo.

La diferencia importa más de lo que parece a primera vista. El autocompletado termina tu frase; un agente termina tu tarea. Supón que escribes, en el directorio de un proyecto, claude, y después: los tests de fechas fallan todos los lunes, averigua por qué. No adivina a partir de la forma de tu pregunta. Busca los tests con Grep, abre los archivos con Read, ejecuta la batería con Bash, se da cuenta de que una función auxiliar da por hecho que la semana empieza en domingo, corrige esa función y vuelve a ejecutar los tests para ver si ahora pasan. Tú miraste; quizá aprobaste un paso o dos; no escribiste el arreglo. Eso sí, tuviste que decidir si el arreglo era correcto. Guarda esa idea. Es la columna vertebral de este libro.

La terminal es donde empezó y donde mucha gente todavía lo conoce, pero ya no vive solo allí. El mismo agente está en una app de escritorio con diffs visuales, en el navegador en claude.ai/code, donde se ejecuta en un contenedor en la nube, dentro de VS Code y JetBrains, en tu móvil, en Slack y en GitHub. Las partes siguientes recorren cada puerta. De momento basta con saber que todas dan a la misma habitación: un modelo, un conjunto de herramientas y un bucle que sigue girando hasta que el trabajo está hecho o te necesita.

Un agente no es un teclado más listo. Es un colega que nunca se cansa y que a veces entiende mal.

¿Qué te pide todo esto? Menos teclear y más criterio. Pasarás el tiempo diciendo con cierta precisión lo que quieres, viendo pasar el trabajo y revisando lo que vuelve. Son habilidades antiguas, las que siempre han tenido los buenos editores y los buenos jefes, aplicadas a un tipo nuevo de colaborador. A algunos lectores esto les resulta un alivio. A otros les inquieta un poco, como descubrir que el lavavajillas tiene opiniones. Las dos reacciones son razonables. Ninguna es motivo para no entrar en la cocina. Abre una terminal en un proyecto que conozcas bien, escribe claude y hazle una pregunta cuya respuesta ya sepas. Luego observa si llega a ella por el mismo camino que tú. Es la calibración más barata que vas a comprar nunca. La terminal aprendió a hablar. Tu trabajo es aprender cuándo escucharla.

Un agente termina la tarea PUERTAS Terminal App de escritorio Web Extensiones de IDE Móvil Slack · GitHub dan a La misma sala Modelo un modelo Claude Herramientas leer, editar, ejecutar El bucle hasta acabar "LOS TESTS FALLAN LOS LUNES" Grep busca tests Read abre archivos Bash corre la suite Edit arregla el helper Bash vuelve a correrla Tú juzgas el arreglo Autocompletado acaba tu frase Agente acaba tu tarea Lo escribe, lo ejecuta, lee el error y reintenta.
Fig. 1 · La terminal aprendió a hablar. Un agente termina la tarea.
Capítulo 2 · Parte I

Breve historia de un año rápido

La historia es corta porque no ha habido mucho tiempo para ella. Claude Code apareció como vista previa de investigación en febrero de 2025, una herramienta de línea de comandos para quien estuviera dispuesto a soltar un modelo en su terminal. Alcanzó la disponibilidad general en mayo de 2025, junto con los modelos Claude 4. En octubre de 2026 es menos una herramienta que una familia de puertas al mismo agente: la CLI, una app de escritorio, la web, extensiones para el IDE, el móvil, Slack, una extensión de Chrome, GitHub Actions y un Remote Control que permite a tu móvil manejar una sesión que se ejecuta en tu propia máquina.

Es mucho cambio para tan poco calendario, y produce un tipo particular de ansiedad. Aprendes un flujo de trabajo el lunes y el jueves lees que alguien tiene uno mejor. Un comando en el que confiabas estrena hermano. El modelo que elegiste tiene un primo más nuevo. Si eres de los que prefieren terminar de aprender algo antes de usarlo, este ritmo es levemente cruel.

La respuesta estoica es separar lo que se mueve de lo que no. Lo que se mueve es la superficie: comandos, menús, la puerta por la que entras, los nombres de los modelos más recientes. Lo que no se mueve es la forma de debajo. Un agente reúne contexto, actúa, verifica el resultado y repite. Tú le dices cómo es «terminado» y compruebas que ha llegado. Los permisos deciden qué puede hacer sin preguntar. Los archivos de memoria le dicen lo que ya debería saber. Esas ideas eran ciertas en la vista previa y lo son ahora. Apréndelas bien y el resto es vocabulario.

Hay también unos pocos hábitos prácticos que convierten el ritmo de amenaza en clima. Si instalas con el instalador nativo, Claude Code se actualiza solo, así que rara vez vas mucho por detrás. Cuando aparezca algo nuevo, escribe /help dentro de una sesión en lugar de rebuscar en hilos llenos del entusiasmo ajeno. Cuando algo se comporte de forma rara tras una actualización, /doctor examinará tu configuración y te dirá lo que encuentre. Y cuando leas una entrada de blog muy segura de sí misma sobre una función, comprueba si la entrada es anterior al último cambio de esa función. Muchas lo son.

Las herramientas rápidas premian los principios lentos.

En un año rápido existe la tentación de adoptarlo todo. Resístela. Cada superficie nueva le sirve a alguien, pero no todas te sirven a ti este mes. Elige la puerta por la que de verdad vas a pasar cada día, aprende sus costumbres y añade la siguiente solo cuando notes una ausencia concreta. Un desarrollador que usa bien la CLI rendirá más que uno que ha instalado todas las extensiones y no se fía de ninguna.

El ritmo continuará. No es un pronóstico, solo una observación sobre los últimos veinte meses. No puedes frenarlo y no necesitas seguirlo entero. Necesitas seguir la parte que toca tu trabajo y saber dónde está escrito el resto para cuando lo necesites. La novedad sale barata. La soltura es lo que da intereses.

Qué cambia y qué permanece FEB 2025 MAY 2025 OCT 2026 Vista previa una herramienta CLI Disponibilidad general con Claude 4 Muchas puertas CLI, web, IDE, móvil Qué cambia comandos y menús qué puerta usas los nombres de modelo Qué permanece reunir, actuar, verificar tú defines y compruebas permisos, memoria HÁBITOS PARA QUE EL RITMO SEA SOLO TIEMPO Instalación nativa se actualiza sola /help pregunta a la sesión /doctor tras una rara actualización Herramientas rápidas premian principios lentos. La soltura se acumula.
Fig. 2 · Breve historia de un año rápido. Qué cambia y qué permanece.
Capítulo 3 · Parte I

Reunir, actuar, verificar

Toda sesión de Claude Code, por grandiosa o trivial que sea, ejecuta el mismo bucle. Reúne contexto, actúa, verifica el resultado y repite hasta que la tarea está hecha o necesita algo de ti. Cuando eres capaz de ver el bucle, puedes dirigirlo. Mientras no lo ves, el agente parece un mago, y a los magos cuesta corregirlos.

Reunir es la parte silenciosa. Pídele que añada limitación de peticiones a una API y no se pondrá a escribir. Usará Glob para encontrar los archivos de rutas, Grep para localizar dónde se gestionan las peticiones y Read para abrir el middleware que ya tienes. Puede que mire el manifiesto de paquetes para ver qué librerías hay instaladas. Es el agente haciendo lo que hace un fichaje sensato su primera mañana: mirar alrededor antes de tocar nada. Si la recogida es pobre, el trabajo será seguro de sí mismo y erróneo. Puedes ayudar señalando las cosas directamente, con una mención @path como @src/middleware/auth.ts, para que empiece en la habitación correcta.

Actuar es la parte por la que viene la gente. Claude modifica un archivo con Edit, crea uno con Write o ejecuta un comando con Bash. Según tu modo de permisos, algunas de estas acciones se detendrán a preguntarte primero. En el modo por defecto, que aparece como Manual, pregunta antes de editar, de ejecutar comandos y de acceder a la red. Esa pausa no es burocracia. Es tu oportunidad de ver la acción antes de que ocurra, que es el momento más barato para objetar.

Verificar es lo que separa a un agente de un autocompletado muy leído. Tras una edición, Claude ejecutará los tests, lanzará la compilación, llamará al endpoint o releerá el archivo para ver si el cambio quedó como se pretendía. Si algo falla, lee el fallo y da otra vuelta. La calidad de este paso depende mucho de que la verificación sea posible siquiera. Un proyecto con batería de tests le da al agente un espejo. Uno sin tests solo le deja su propia opinión, que es tan fiable como la tuya a las dos de la madrugada.

Así que dile cómo comprobarlo. Añade limitación de peticiones a la ruta de login, luego ejecuta npm test y enséñame la salida es mejor instrucción que añade limitación de peticiones, porque nombra la línea de meta. Te sorprenderá cuántas veces la diferencia entre una buena sesión y una embarullada es una sola frase sobre la verificación.

El bucle es tan honesto como su último paso.

Puedes entrar en el bucle en cualquier momento. Pulsa Esc y Claude detiene lo que está haciendo; puedes redirigirlo sin perder la sesión. También puedes escribir mientras trabaja, y tu mensaje espera en cola hasta que vuelva a levantar la vista. Si se ha ido por donde no querías, pulsa Esc dos veces, o usa /rewind, para devolver código y conversación a un punto de control anterior. Nada de esto es de mala educación. Así es como debe funcionar la colaboración. Observa tres o cuatro sesiones con el bucle en mente y empezarás a notar dónde se tuercen las tuyas. Casi siempre es el primer paso o el último. El del medio, curiosamente, suele arreglárselas solo.

Cada sesión ejecuta un bucle Reunir contexto Glob · rutas Grep · handlers Read · middleware Actuar Edit · Write · Bash Manual pregunta antes el mejor momento para objetar Verificar npm test · build llama al endpoint ¿falla? léelo y repite actúa comprueba repite Señala primero @src/middleware/ Nombra la prueba "luego corre npm test" Intervén cuando quieras Esc · Esc Esc · /rewind El bucle es tan honesto como su último paso.
Fig. 3 · Reunir, actuar, verificar. Cada sesión ejecuta un bucle.
Capítulo 4 · Parte I

Instalar sin ceremonias

La instalación es lo menos interesante de Claude Code y debería ocuparte el menor tiempo posible. Hay un puñado de caminos, todos cortos, y el bueno es aquel en el que no tendrás que volver a pensar.

El camino recomendado es el instalador nativo. En macOS, Linux o WSL, abre una terminal y ejecuta curl -fsSL https://claude.ai/install.sh | bash. En Windows hay una línea equivalente de PowerShell en la documentación oficial. La virtud de la instalación nativa no es la velocidad sino el mantenimiento: se mantiene actualizada en segundo plano. Con lo deprisa que cambia la herramienta, eso vale más de lo que parece. Una instalación desfasada es la razón más habitual de que un capítulo como este no parezca coincidir con tu pantalla.

Si prefieres un gestor de paquetes, hay dos caminos bien trillados. En un Mac, brew install --cask claude-code funciona como cabría esperar. En Windows, WinGet hace lo mismo. Son opciones perfectamente válidas para quien gestiona todo con una sola herramienta y le gusta así. Solo ten claro quién se encarga de las actualizaciones, porque un cask que nunca actualizas envejece en silencio mientras la documentación sigue adelante sin él.

Elige la instalación que vayas a olvidar, y luego olvídala.

Una vez instalado, ve al directorio de un proyecto y escribe claude. La primera ejecución te pide iniciar sesión. Necesitas o bien una suscripción a Claude, como Pro, Max, Team o Enterprise, o bien facturación por API mediante una clave de Anthropic o un proveedor en la nube. Elige la que encaje con cómo pagáis ya tú o tu organización; la parte siguiente de este libro dedica un capítulo a la diferencia. Hecho eso, el prompt te espera y puede empezar el trabajo de verdad.

Ahora la parte que nadie menciona hasta que sale mal. A veces se enfurruña. No encuentra el comando, o arranca pero no consigue autenticarse, o se comporta como si un ajuste que hiciste no existiera. Antes de buscar en internet, ejecuta /doctor dentro de una sesión. Diagnostica tu instalación y tu configuración y te dice lo que encuentra, que suele ser algo prosaico: dos copias instaladas por dos caminos distintos, un PATH que no incluye el binario, un archivo de ajustes con una coma perdida. /status es su compañero más amable, y vale la pena echarle un vistazo cuando sospechas que la sesión no está configurada como crees.

Un poco de higiene compensa aquí. Instala por un único camino; si cambias, quita el anterior. Mantén ordenado el PATH de tu shell. Si trabajas en varias máquinas, usa el mismo método en todas, para que un problema en una tenga la misma solución en las demás. Y si lo estás configurando para un equipo, escribe el paso de instalación en las notas de incorporación del proyecto, en una línea, para que la próxima persona no invente un sexto método. Nada de esto es glamuroso. Precisamente de eso se trata. La mejor instalación es la que nunca tienes que recordar haber hecho.

Instala una vez y olvídate ¿Qué vía? recomendado Windows Instalador nativo curl … install.sh | bash se actualiza sola Homebrew brew install --cask actualizas tú WinGet gestor de paquetes actualizas tú claude en una carpeta Inicia sesión plan o API falla Cuando falla /doctor · diagnostica /status · revisa el setup ¿dos instalaciones? ¿PATH? ¿coma suelta? Higiene una sola vía igual en cada equipo una línea en onboarding La mejor instalación es la que no recuerdas haber hecho.
Fig. 4 · Instalar sin ceremonias. Instala una vez y olvídate.
Capítulo 5 · Parte I

Tus primeros cinco minutos

Elige un repositorio que conozcas razonablemente bien. No el más importante de la empresa, ni un juguete que hiciste anoche; algo intermedio, donde reconocerías una respuesta equivocada. Abre allí una terminal y escribe claude. Ya estás en una sesión, y el cursor espera a que digas algo sensato.

Empieza pidiéndole que te explique la base de código. Algo así: Explícame cómo está organizado este proyecto, como si empezara aquí el lunes. ¿Por dónde entra una petición y dónde se guardan los datos? Fíjate en lo que hace antes de responder. Listará archivos, buscará y abrirá unos cuantos. La respuesta que vuelve pone a prueba dos cosas a la vez: si el agente lee bien y si tu proyecto se deja leer. Si se equivoca con la estructura, puede ser culpa del agente; también puede ser que tu estructura sea de verdad confusa, cosa que conviene saber.

Después, haz un cambio diminuto. No una funcionalidad; una mejora pequeña y comprobable. Corrige un mensaje de error engañoso, añade una descripción de --help que falta, arregla el paso de instalación del README que todo el mundo se salta en silencio. Sé concreto: En @README.md, la sección de instalación dice que ejecutes make setup, pero el Makefile no tiene ese objetivo. Corrige las instrucciones para que coincidan con el Makefile. Las peticiones concretas producen diffs pequeños, y los diffs pequeños son los que de verdad puedes revisar.

Cuando quiera editar, preguntará. En el modo de permisos por defecto, que aparece como Manual, cada edición y cada comando esperan tu aprobación. En una primera sesión es exactamente lo que quieres. Lee cada cambio propuesto según aparece. Si la redacción no te convence, dilo en lenguaje llano y deja que lo revise. No estás siendo quisquilloso. Estás calibrando.

El primer diff que apruebas te enseña más que los diez primeros que hojeas.

Luego revisa el cambio en conjunto. En la terminal, pídele que te enseñe el diff, o ejecuta tú git diff. Si prefieres algo más visual, la app de escritorio y la extensión de VS Code muestran los cambios en línea. Busca las ediciones que pediste, y después las que no pediste. Un agente servicial a veces ordena una línea vecina ya que pasaba por allí. Puede estar bien. Nunca debería ser una sorpresa. Por último, haz commit. Puedes pedírselo a Claude, que escribirá un mensaje razonable, o hacerlo tú para conservar la ceremonia en tus manos. En cualquier caso, el cambio queda en git, y eso importa porque git es tu verdadera red de seguridad. Claude Code guarda sus propios puntos de control de las ediciones, pero son una comodidad, no un historial.

Cinco minutos, una explicación, un cambio pequeño, una revisión honesta, un commit. Esa es toda la forma del trabajo, en miniatura. Las tareas grandes son casi la misma forma con más paciencia en el medio. Si la sesión fue bien, prueba mañana un cambio algo mayor. Si fue mal, mira dónde: casi siempre la petición era más vaga de lo que parecía al escribirla. Empieza por poco. El agente no se ofenderá, y tus compañeros tampoco.

Cinco minutos, una revisión honesta 01 Explicar el código 02 Cambio mínimo verificable 03 Aprobar Manual pregunta 04 Revisar git diff 05 Commit a git Sé concreto En @README.md el paso de instalación dice make setup. El Makefile no tiene ese target. Lee todo el diff los cambios pedidos y los no pedidos nunca una sorpresa Checkpoints una comodidad git tu red de seguridad El primer diff que apruebas enseña más que diez que hojeas.
Fig. 5 · Tus primeros cinco minutos. Cinco minutos, una revisión honesta.
Capítulo 6 · Parte I

Las herramientas son las manos

Un modelo por sí solo solo puede producir texto. Lo que lo convierte en agente es un conjunto de herramientas: capacidades con nombre, acotadas, que le permiten tocar el mundo. Las herramientas de Claude Code tienen nombres sencillos, y merece la pena aprenderlos, porque esos nombres son también las asas con las que concedes y niegas permisos.

Primero, las herramientas de lectura. Read abre un archivo. Glob encuentra archivos por patrón, de modo que puede responder a ¿dónde están todos los archivos de test? sin abrir nada. Grep busca en el contenido de los archivos, que es como Claude encuentra todas las llamadas a una función antes de cambiar su firma. Estas tres son la forma en que el agente reúne contexto, y en general son inofensivas: mirar no es tocar. Las herramientas de escritura son Edit, que cambia una parte de un archivo existente, y Write, que crea un archivo o lo sustituye entero. La distinción es práctica. Un Edit es un cambio quirúrgico que puedes revisar línea a línea. Un Write es una página nueva entera, y merece una mirada algo más dura.

Luego está Bash, que ejecuta comandos de shell. Bash es la herramienta más potente de la caja y, por tanto, la que hay que pensar. Es como Claude ejecuta tus tests, lanza tu compilación, instala una dependencia o comprueba git status. Es también, en principio, como podría borrar un directorio. Casi toda la maquinaria de permisos que conocerás más adelante existe por culpa de Bash.

Dos herramientas salen de tu máquina. WebFetch recupera una página concreta, como la documentación actual de una librería cuya API cambió el mes pasado. WebSearch busca cosas cuando Claude no conoce la página. Por último, Agent lanza un subagente: un trabajador aparte, con su propio contexto, que se va, hace un trozo de investigación o de trabajo y vuelve solo con su informe. Conocerás a los subagentes como es debido en una parte posterior. De momento, basta saber que evitan que la conversación principal se llene con cada archivo que tocó una búsqueda.

Una regla de permisos es tan precisa como el nombre de herramienta que lleva dentro.

Por esto importan los nombres. Las reglas de permisos de un archivo de ajustes se escriben contra ellos. "allow": ["Bash(npm test)"] deja que Claude ejecute tu comando de tests sin preguntar. "allow": ["WebFetch(domain:github.com)"] le deja leer páginas de GitHub libremente. "deny": ["Bash(rm -rf *)"] prohíbe de plano cierto tipo de desastre, y deny gana a allow en todos los modos. Puedes ver y editar estas reglas con /permissions. Las herramientas que vienen de servidores MCP también siguen un patrón, y aparecen como mcp__<server>__<tool>, de modo que se pueden permitir o denegar por el mismo método.

Cuando aparece una petición de permiso, nombra la herramienta y muestra lo que quiere hacer. Lee esa línea. En una semana notarás que apruebas las mismas pocas cosas una y otra vez, normalmente ejecuciones de tests y lecturas, y esas son buenas candidatas a una regla allow. Las peticiones que rara vez ves son las que vale la pena mantener como peticiones. Aprende cómo se llaman las manos y sabrás cuáles atar y cuáles dejar libres.

Los nombres de herramienta son permisos Mirar Read · Glob · Grep mira, no toca Cambiar Edit · Write Write: mira mejor Ejecutar Bash más poder, más reglas Salir fuera WebFetch · WebSearch más allá de tu equipo Delegar Agent solo devuelve un informe REGLAS DE SETTINGS allow Bash(npm test) allow WebFetch(domain:github.com) deny Bash(rm -rf *) Herramientas MCP mcp__server__tool deny gana a allow ver y editar con /permissions Una regla es tan precisa como su nombre de herramienta.
Fig. 6 · Las herramientas son las manos. Los nombres de herramienta son permisos.
Capítulo 7 · Parte I

Elegir una mente

Claude Code funciona con modelos Claude, y tú eliges cuál. A finales de 2026 la familia incluye Opus 5.5, Sonnet 5.5, Haiku 4.5 y Fable 5.1. La documentación describe para qué sirve cada uno, y cambia a medida que la familia crece, así que toma cualquier resumen de aquí, incluido el mío, como punto de partida y no como ley. Cambiar es sencillo. Escribe /model en una sesión y elige de la lista. La elección se mantiene durante esa sesión, y puedes cambiarla a mitad de camino si el trabajo cambia de carácter. También puedes fijar un valor por defecto en tu archivo de ajustes con la clave model, para que cada sesión nueva empiece donde sueles quererla.

El segundo dial es el esfuerzo. /effort fija cuánto razona el modelo antes de actuar, con niveles como low, medium, high, xhigh y max. Más esfuerzo significa más pensamiento: planes más cuidadosos, más atención a los casos límite, y más tokens y más tiempo para llegar. Menos esfuerzo es expeditivo. Ninguno es mejor en abstracto. Renombrar una variable no necesita pensamiento profundo, y un fallo de concurrencia en un flujo de pagos no merece uno rápido.

El hábito útil es elegir por tarea, no por vanidad. Hay una fuerte tentación de usar siempre el modelo más grande al máximo esfuerzo, con la teoría de que no se debe escatimar en inteligencia. La teoría suena noble y funciona mal. Un modelo de peso pesado a máximo esfuerzo, al que le pides corregir una errata, corregirá la errata tras una pausa lo bastante larga como para que te preguntes si ha muerto. Mientras tanto, tu consumo se va por el desagüe para nada. Ajusta la mente al trabajo: un todoterreno capaz para el día a día, más profundidad cuando el problema es de verdad difícil o ambiguo, algo más ligero y rápido para las tareas mecánicas.

El modelo adecuado es el más barato que hace bien el trabajo.

Está también la cuestión del contexto. Los modelos compatibles ofrecen una ventana de hasta un millón de tokens, lo bastante grande para albergar una base de código considerable más una conversación larga. Es tentador tomarlo como permiso para dejar de pensar en el contexto. No lo hagas. Una ventana grande significa menos interrupciones, no atención infinita. Un modelo al que se le da todo todavía tiene que encontrar lo que importa, y una sesión atestada de tres enfoques abandonados es más difícil de dirigir que una nueva. Usa /context para ver qué está llenando la ventana, y /clear cuando cambies de tema.

Un buen patrón de trabajo es este. Empieza el día con tu modelo habitual a un esfuerzo moderado. Cuando una tarea se resista, cuando el agente dé dos vueltas al bucle sin avanzar, sube el esfuerzo antes de cambiar nada más, porque muchas veces lo que faltaba era profundidad. Cuando llegue una racha de cambios rutinarios, vuelve a bajarlo. Trata los diales como los cambios de una bicicleta: los tocas por la cuesta, no por la imagen que tienes de ti mismo.

Nadie te va a dar una medalla por usar el modelo más grande para arreglar un README. Elige la mente que la tarea necesita y reserva el pensamiento pesado para los problemas que se lo han ganado.

Elige la mente según la tarea Esfuerzo inútil máximo para una errata lento, gasta cuota Esfuerzo justificado bug de concurrencia en un flujo de pago Ágil y correcto renombrar variable tareas mecánicas Demasiado poco dos vueltas sin avance sube el esfuerzo alto esfuerzo bajo rutina dificultad difícil LOS DIALES /model Opus 5.5 · Sonnet 5.5 Haiku 4.5 · Fable 5.1 /effort low · medium · high xhigh · max /context hasta 1M tokens /clear al cambiar de tema El modelo correcto es el más barato que hace bien el trabajo.
Fig. 7 · Elegir una mente. Elige la mente según la tarea.
Capítulo 8 · Parte I

Pagar por el privilegio

Claude Code cuesta dinero, y es mejor entender cómo antes de que la factura o el límite se presenten solos. No voy a citar precios. Cambian, y un libro que los cita se estropea antes que la leche. Lo que no cambia mucho es la estructura.

Hay dos formas de pagar. La primera es una suscripción a Claude: Pro, Max, Team o Enterprise. Inicias sesión con tu cuenta de Claude y tu uso de Claude Code tira de ese plan. La segunda es la facturación por API, con una clave de API de Anthropic o a través de un proveedor en la nube que tu organización ya use. Aquí pagas lo que consumes. Las suscripciones convienen a personas y equipos que quieren previsibilidad. La facturación por API conviene a organizaciones que ya canalizan su gasto por una cuenta en la nube, y al trabajo automatizado que necesita medirse con precisión. Muchos equipos usan ambas: suscripciones para las personas, facturación por API para los pipelines.

En cualquier caso, hay límites de uso. Una suscripción no es un bufé libre; los planes tienen asignaciones, y los días intensos pueden alcanzarlas. La facturación por API tiene sus propias restricciones. Las cifras exactas pertenecen a la documentación, que estará al día cuando este capítulo ya no lo esté. Lo que importa es que el límite existe y que puedes ver lo cerca que estás de él.

Dos comandos ayudan. /cost muestra lo que ha gastado la sesión actual. /usage muestra cuánto has consumido. Échales un vistazo al final de cada sesión larga durante una semana y desarrollarás un instinto para saber qué tipo de trabajo sale caro. Rara vez es el que esperas. Una sesión que releyó doce veces el mismo archivo de log enorme gastará más que una que escribió una funcionalidad entera.

Gasta atención antes que tokens. La atención es más barata y da intereses.

Esa frase es el corazón práctico de este capítulo. La mayor parte del desperdicio no la causa un modelo grande ni un esfuerzo alto. La causan las peticiones vagas. Mejora el dashboard invita al agente a leerlo todo, probar varias cosas y preguntar qué querías decir. Haz que el spinner de carga del dashboard aparezca solo pasados 300 milisegundos, en @src/components/Dashboard.tsx cuesta una fracción de eso, y produce algo que puedes revisar en un minuto. Treinta segundos de pensar tú sustituyen muchos minutos de explorar él.

Otros cuantos hábitos ayudan. Usa /clear cuando cambies de tema, para que la siguiente tarea no arrastre el contexto de la anterior. Deja que /compact resuma una sesión larga en lugar de cargar con cada intercambio. Elige el esfuerzo a propósito, como sugería el capítulo anterior. Y si te descubres repitiendo la misma explicación en cada sesión, ponla de una vez en un archivo CLAUDE.md, que una parte posterior trata a fondo. Nada de esto es tacañería. Es la misma disciplina que hace bueno un encargo a un contratista: alcance claro, meta conocida, no pagar a nadie por pasearse por el edificio buscando el problema. Al agente no le importa pasearse. A tu presupuesto, sí. El dinero gastado en claridad es el único del que nunca te arrepientes.

Gasta atención antes que tokens Tokens que podrías gastar lo lee todo, adivina Atención que gastas 30 s de encargo claro Trabajo entregable revísalo en un minuto Vago mejora el dashboard Concreto spinner tras 300 ms DOS FORMAS DE PAGAR Suscripción Pro · Max · Team · Enterprise para personas Facturación API clave API o nube para pipelines /cost · /usage cuánto falta al límite /clear · /compact y CLAUDE.md, una vez El dinero en claridad es el único que nunca lamentas.
Fig. 8 · Pagar por el privilegio. Gasta atención antes que tokens.
Capítulo 9 · Parte I

En qué es malo

Todo manual honesto tiene un capítulo sobre el fracaso, y es este. Claude Code es muy bueno en muchísimas cosas. También es malo en unas pocas, y el problema es que a menudo lo es con la misma voz tranquila y fluida que usa cuando acierta. Conocer la forma de sus fallos es el principio de usarlo bien.

El primero es el error seguro de sí mismo. De vez en cuando el agente te dirá que una función hace algo que no hace, o informará de que los tests pasan cuando ejecutó los tests equivocados, o explicará un bug con una historia coherente y falsa. No es que mienta. Es la naturaleza de un sistema que produce texto plausible, y plausible es una propiedad distinta de verdadero. La defensa no es sospechar de todo; eso sería agotador. La defensa son las pruebas. Pídele que te enseñe la salida de los tests, no que te la describa.

El segundo son las suposiciones caducadas. El modelo aprendió de datos con una fecha de corte, y las librerías se mueven. Puede echar mano de una API que cambió de nombre la primavera pasada, o de una opción de configuración que ya no existe. Cuando algo falle de una forma que huela a desfase de versiones, apúntale a la documentación actual con WebFetch, o dile qué versión usas. Se adapta deprisa en cuanto lo sabe. No puede saber lo que no se le ha enseñado.

El tercero son las tareas vagas. Limpia este módulo no tiene línea de meta, así que el agente se inventará una, y puede que no sea la tuya. Quizá renombre la mitad de las variables, extraiga tres funciones auxiliares y reescriba un bucle que funcionaba solo por elegancia. Cada cambio es defendible; el total es un diff que nadie quiere revisar. Las tareas vagas no son tanto un fallo del agente como un fallo compartido, pero lo que tendrás que limpiar será su salida.

La fluidez no es exactitud. Trata una respuesta pulida como un borrador.

El cuarto es el gusto. Claude puede decirte que un diseño es incoherente, y puede seguir una guía de estilo con verdadero esmero. Lo que no puede hacer de forma fiable es saber cuál de tres enfoques razonables le seguirá gustando a tu equipo dentro de un año, o que tus usuarios odian cierto tipo de ventana modal, o que la abstracción elegante es un error porque el producto está a punto de cambiar de rumbo. El gusto es contexto acumulado sobre personas y consecuencias. Tú tienes más que cualquier modelo, y deberías seguir ejercitándolo.

El antídoto para los cuatro es el mismo: verificar. Asegúrate de que hay una forma de comprobar el trabajo, y úsala. Tests, una compilación que funciona, una petición real contra el endpoint, una lectura atenta del diff. El modo plan también ayuda. Pulsa Shift+Tab hasta que aparezca, y Claude leerá y propondrá sin editar, de modo que puedas corregir una suposición equivocada antes de que se convierta en cuarenta líneas cambiadas. Y cuando la respuesta parezca demasiado redonda, pídele que se lleve la contraria. Es sorprendentemente bueno encontrando el agujero en su propia historia cuando se le invita a buscarlo. El agente no es poco fiable. Es fiable como lo es un desconocido capaz: útil desde la primera hora, y digno de confianza en la medida en que lo hayas comprobado.

Fluido no es lo mismo que correcto Errores seguros "tests pasan" corrió otros muestra la salida Datos caducos una API renombrada tras el corte WebFetch a la doc Tareas vagas sin meta y se inventa una nombra la prueba Criterio qué envejece bien qué odian los usuarios que siga siendo tuyo un antídoto Verificación tests · build · petición real · diff Modo plan Shift+Tab: propone, no edita Que se contradiga busca el hueco ayuda ayuda Confía en proporción a lo que has comprobado.
Fig. 9 · En qué es malo. Fluido no es lo mismo que correcto.
Capítulo 10 · Parte I

Delegar, no autocompletar

Todo lo de esta parte se reduce a un cambio en cómo ves tu propio papel. Con el autocompletado sigues siendo el autor; la herramienta sugiere la palabra siguiente y tú la aceptas o la rechazas. Con Claude Code eres otra cosa. Eres quien decide qué hay que hacer, lo entrega y juzga lo que vuelve. Te has convertido en el editor.

No es una degradación. Los editores siempre han sido quienes saben para qué es el texto. No escriben cada frase, pero deciden qué frases sobreviven. En términos de software, tú defines la tarea, las restricciones y, sobre todo, cómo es «terminado». Luego lees el diff como un editor lee un borrador: para ver si hace lo que se pidió, si hace algo que no se pidió y si dentro de seis meses avergonzaría a alguien.

Definir «terminado» es la habilidad que más rinde. Una buena definición nombra una comprobación que se puede ejecutar de verdad. La importación admite archivos con marca de orden de bytes; añade un test con un archivo así; la batería pasa es una tarea con línea de meta. Haz las importaciones más robustas es un estado de ánimo. Cuando le das al agente una línea de meta, puede verificar su propio trabajo dentro del bucle, y tu revisión se convierte en una confirmación en lugar de una investigación.

Delegar es el arte de decir exactamente lo que quieres, y luego comprobar que lo has recibido.

Hay cosas que deberías quedarte. Las decisiones difíciles de revertir, como borrar datos, publicar una versión o cambiar una interfaz de la que dependen otros equipos, siguen siendo tuyas. Los juicios de gusto siguen siendo tuyos. También la lectura final de todo lo que sale con tu nombre. El sistema de permisos, que trata una parte posterior, existe para hacer explícitas estas fronteras: el agente puede ejecutar los tests sin preguntar, pero debe preguntar antes de hacer push.

También hay cosas que deberías soltar, y a mucha gente esto le cuesta más. No necesitas teclear el código repetitivo, cazar cada llamada a una función ni recordar el flag de aquel comando. No necesitas vigilar cada paso una vez que te fías del bucle para cierto tipo de tarea. Estar encima de alguien en quien has delegado es un fallo conocido en los equipos humanos, y aquí es el mismo fallo: te cuesta atención y no te enseña nada nuevo.

Así que la postura de trabajo para el resto del libro es fácil de enunciar y lleva un tiempo practicarla. Di lo que quieres con precisión. Di cómo se va a comprobar. Deja trabajar al agente. Revisa lo que te devuelve como lo haría un editor, con honradez y con tu nombre encima. Con el tiempo ampliarás lo que delegas, no porque el agente haya cambiado sino porque habrás aprendido dónde es fiable. La planta baja está puesta. Sabes qué es la herramienta, cómo gira su bucle, cómo se llaman sus manos, qué mente elegir, cuánto cuesta y dónde tropieza. Todo lo que hay por encima de esta planta es detalle y palanca. Dejaste de ser el mecanógrafo. Sigues siendo, y siempre serás, quien dice que está terminado.

De autor a editor Tú el editor Claude Code el delegado define el final una prueba ejecutable trabaja, verifica corre su prueba entrega un diff pequeño y verificable revisa como editor ¿pedido? ¿extra? ¿en 6 meses? aprueba o devuelve Conserva decisiones irreversibles criterio y lectura final Suelta boilerplate, buscar llamadas vigilar cada paso Dejaste de teclear. Sigues decidiendo cuándo está terminado.
Fig. 10 · Delegar, no autocompletar. De autor a editor.
Avance gratuito · Parte I

Sigue leyendo

Has leído los primeros 10 de 100 capítulos de Claude Code: la guía definitiva 2026. El libro completo incluye todos los capítulos y láminas, en PDF y EPUB, en inglés, francés, polaco y español.

¿Ya lo compraste? Lee la edición completa en línea

Claude Code: la guía definitiva 2026 · Primera edición, octubre de 2026
100 capítulos · 10 partes · cien diagramas
por Mat Siems · MS Books, No. 7 · 2026