Comandos de barra de Claude Code: sesiones más largas y limpias

Comandos de barra vs flags de CLI vs atajos de teclado

Los flags de CLI configuran cómo se ejecuta Claude Code, los atajos de teclado gestionan interrupciones en tiempo real y los comandos de barra te dan control granular una vez dentro de la sesión. 

Las tres capas existen porque surgen necesidades distintas en momentos distintos del flujo de trabajo. No usarás todas en cada sesión, pero saber que están ahí te permite elegir la herramienta adecuada cuando la necesitas.

Los comandos de barra se escriben directamente dentro de una sesión activa. Empiezan con / (p. ej., /compact, /plan o /clear) y se ejecutan al instante. Controlan lo que pasa ahora mismo, dentro de la conversación en la que estás.

Los flags de CLI se establecen al lanzar Claude Code desde el terminal. Cosas como claude --model claude-opus-4-6 o claude --continue son flags de CLI. Configuran la sesión antes de empezar. Puedes leer más sobre todos los flags en nuestro Claude Code CLI tutorial.

Los atajos de teclado operan a nivel de interfaz. Esc interrumpe una respuesta en curso. Pulsar dos veces Esc abre el menú de rebobinado. Shift+Tab alterna entre modo plan, aceptar ediciones y modo automático. Deberían ser atajos de memoria muscular para lo que haces a menudo.

Este artículo se centra en los comandos de barra, los que usas entre prompts, con atajos de teclado cuando coinciden con un comando concreto.

¿Cuáles son los comandos más importantes de Claude Code?

La siguiente tabla recoge los 13 comandos más importantes, todos cubiertos en esta guía.

Ten en cuenta que /cost es ahora un alias de /usage en las versiones más recientes de Claude Code, y /fork es un alias de /branch.

Puedes ver todas las opciones escribiendo / en tu sesión de Claude.

Cómo gestionar la ventana de contexto de Claude Code

Para gestionar la ventana de contexto en Claude Code, una habilidad clave para cualquier usuario avanzado, usa los comandos /compact, /clear y /context.

¿Qué es la ventana de contexto en Claude Code?

La ventana de contexto es la memoria de trabajo de tu sesión. Contiene mucha información: 

• El historial de la conversación
• Contenido de archivos
• Salidas de comandos
• Tus instrucciones de CLAUDE.md
• Contexto de MCP
• Prompts de sistema de Claude

A medida que se llena, Claude Code empieza a perder de vista partes anteriores de la sesión, como la estructura de archivos que describiste al principio, las restricciones que marcaste y otra información clave. La calidad se degrada antes de alcanzar el límite, no solo al alcanzarlo.

/compact

El comando /compact resume los turnos más antiguos de tu conversación y los reemplaza por una versión comprimida, liberando tokens y manteniendo a Claude al tanto de lo ocurrido antes en la sesión. Lo ideal es ejecutarlo pronto y ser intencional con lo que le pides que conserve.

La invocación básica es simplemente /compact. Pero es más útil decirle qué conservar: por ejemplo, puedes indicar a Claude /compact focus on the auth module o /compact retain the error handling patterns we discussed.

Cuando pasas instrucciones, el resumen que genera Claude destacará esos temas sobre el resto. Para profesionales de datos, podría ser algo como /compact focus on the schema decisions and the pipeline DAG, de modo que la arquitectura de alto nivel se mantenga en foco aunque los detalles de depuración línea a línea se compriman.

Una regla útil de la comunidad: compacta antes de superar el 80% de uso del contexto. Si esperas a llenarlo, el resumen será de menor calidad porque Claude ya estará funcionando en un estado degradado. 

Un apunte importante: el contenido de CLAUDE.md, las skills cargadas y los archivos de memoria se conservan automáticamente durante la compactación. No necesitas pedirlo explícitamente.

/clear

El comando /clear borra por completo el historial de la conversación y empieza de cero. Úsalo en los cambios de tarea.

Opcionalmente, puedes pasar un nombre para etiquetar la sesión antes de limpiar: /clear payment-refactor. Esto etiqueta la sesión antigua en el selector de /resume para poder volver a ella más tarde.

Cuando terminas de depurar un cargador de datos y vas a trabajar en un módulo de visualización totalmente distinto, arrastrar el contexto anterior estorba más que ayuda. Empezar con una pizarra en blanco evita confusiones, no arrastra restricciones que ya no aplican y centra toda la atención en la nueva tarea.

Usa /compact para seguir con el mismo trabajo con menos lastre de contexto, y /clear para cambiar a un trabajo distinto.

/context

Antes de decidir si compactar o limpiar, conviene saber cómo está la cosa. El comando /context visualiza el uso actual de la ventana de contexto como una cuadrícula de colores y te muestra exactamente adónde van los tokens.

Verás un desglose por categoría: 

• Historial de conversación
• Contenido de archivos
• Archivos de memoria
• Skills cargadas

Lo bueno es que Claude propondrá optimizaciones si algún elemento está consumiendo un espacio inusual. Pasa all para ampliar el desglose por elemento: /context all

Acostúmbrate a ejecutar /context antes de empezar cualquier tarea grande. Si la ventana ya está al 60% por lo que hiciste antes, ponerte a refactorizar varios archivos sin compactar o limpiar primero es receta para la frustración.

Cómo planificar y revisar cambios en Claude Code

La forma más rápida de montar un lío con código asistido por IA es dejar que empiece a editar archivos sin un plan claro. Para evitar que instrucciones ambiguas generen cambios incoherentes, usa /plan y diff.

/plan

Con /plan, Claude entra en modo solo lectura: analiza la base de código, propone un plan de acción y espera tu aprobación antes de hacer cambios. 

Puedes usarlo con una descripción para darle ventaja: /plan refactor the feature engineering pipeline to support lazy evaluation. No escribirá ni borrará nada hasta que des luz verde. Una vez lo revises y apruebes, Claude ejecuta el plan completo.

El atajo de teclado para alternar el modo plan es Shift+Tab, más rápido que teclear el comando si ya estás en mitad de una sesión y quieres cambiar de modo al vuelo.

El modo plan es especialmente útil en 3 situaciones: 

• Cuando no conoces bien una base de código
• Cuando un cambio afecta a muchos archivos
• Cuando las instrucciones son intrínsecamente ambiguas

Sirve para cualquier tarea: migrar un feature store, refactorizar lógica de ETL o actualizar scripts de entrenamiento que han acumulado años de cambios puntuales.

Para profundizar, te recomiendo nuestro tutorial completo sobre este enfoque: Claude Code Plan Mode: bucles de refactorización con revisión de diseño primero.

/diff

Con /diff se abre un visor de diferencias interactivo que muestra todos los cambios de archivos de la sesión actual.

Sirve para revisar rápido y confirmar que no ha pasado nada raro, como cambios inesperados de archivos o ampliación indeseada del alcance. Piénsalo como el último control entre "Claude ha hecho cosas" y "tengo claro qué va en este commit".

Dentro del visor, navegas con las flechas. Izquierda y derecha alternan entre el diff acumulado actual de git y los diffs por turno. Arriba y abajo cambian de archivo dentro de la vista. Así ves lo ocurrido en toda la sesión y en cada vuelta.

Cómo mantener a Claude Code en el buen camino

Para evitar que las sesiones complejas pierdan el hilo y contaminen el contexto con tangentes, usa los comandos /goal y /btw.

/goal

El comando /goal de Claude Code establece un objetivo de alto nivel que persiste entre turnos y mantiene a Claude trabajando hacia un resultado definido. 

Una vez fijado el objetivo, Claude continúa automáticamente hasta que se cumpla la condición descrita. Es especialmente útil para migraciones largas, arreglos amplios de baterías de tests o cualquier tarea que, de lo contrario, te obligaría a volver a pedirle que siga.

Lo usas indicando el resultado específico que quieres. Ayuda escribir objetivos claros, bien definidos y con estado final concreto, como /goal All tests in the data pipeline are passing with no deprecation warnings.

Mientras hay un objetivo activo, aparece una superposición de progreso en la barra de estado con tiempo transcurrido, número de turnos y uso de tokens. Cuando se cumple, Claude se detiene e informa de la finalización. 

Para quitar un objetivo antes de alcanzarlo: /goal clear.

Para un enfoque similar pero distinto, lee nuestro tutorial sobre desarrollo dirigido por especificaciones en Claude Code.

/btw

El comando /btw te permite hacer una pregunta lateral que no pasa a formar parte del hilo principal.

Claude la responde en una superposición y la conversación principal continúa exactamente donde estaba: /btw what was that config option for SQLAlchemy connection pooling called again? 

Me pasa mucho: Claude está trabajando y me surge una duda sobre el proceso. Si lo paro para preguntar, añado ruido y puede que tenga que reiniciar la tarea. Si ignoro la duda, la pierdo. El comando /btw lo resuelve de forma limpia.

Piénsalo como una nota adhesiva que te pasas a ti mismo a mitad de tarea: obtienes la respuesta que necesitas sin el coste de contexto o tiempo de una desviación.

Cómo navegar por las sesiones en Claude Code

Los proyectos largos no caben en una sola sesión. Necesitas retomar trabajos antiguos, experimentar sin romper avances y, a veces, deshacer cambios que se torcieron. Los comandos /resume, /branch y /rewind te ayudan a hacerlo.

/resume

Con /resume puedes continuar una sesión anterior. Si lo ejecutas sin argumentos, verás un selector con las sesiones recientes ordenadas por fecha y un resumen del último prompt. Pasa un nombre o ID de sesión para saltar directamente: /resume payment-refactor

También puedes hacerlo desde la línea de comandos antes de empezar. Con claude --continue (o claude -c) reanudas la sesión más reciente, y con claude --resume <id> reanudas por ID. Los flags de CLI y el comando de barra logran lo mismo; usarías la CLI antes de iniciar una sesión o el comando de barra si ya estás en una.

Claude Code guarda cada sesión localmente en ~/.claude/projects/ como un archivo JSONL, registrando cada mensaje, uso de herramientas y resultado. Esto hace posible reanudar, rebobinar y ramificar.

/branch

El comando /branch crea una copia de la conversación en su estado actual, te cambia a la nueva rama y deja el original tal cual. Incluso puedes nombrarlas: /branch try-polars-instead-of-pandas

Es el equivalente conversacional de una rama de git. Si quieres probar un enfoque distinto sin perder el que ya tienes, crea una rama, prueba la alternativa y, si no funciona, puedes /resume volver al original. Si funciona, tienes una rama limpia con el camino mejor.

También es útil si tu ventana de contexto se está llenando y te enfrentas a dos problemas separados que dependen del contexto reunido en el chat activo.

/branch también está disponible como /fork, y en recursos y tutoriales antiguos verás a menudo /fork. El nombre canónico en la documentación oficial actual es /branch, pero ambos funcionan.

/rewind

Si te has pasado de frenada y te das cuenta de que ha habido errores, /rewind hace retroceder la sesión a un turno anterior como si fuera un botón de deshacer. 

Lo mejor es que obtienes un menú interactivo. Navega con las flechas y elige el turno al que quieres volver. 

La clave es elegir qué rebobinar:

• Ambos (por defecto): los archivos se restauran al estado de ese turno y se borran los mensajes posteriores. Úsalo cuando una secuencia de cambios salió mal y quieres reiniciar limpio desde un estado conocido.
• Solo conversación: elimina los mensajes posteriores al punto elegido, pero mantiene los cambios de archivos. Útil si las respuestas posteriores no ayudaron, pero el código generado sí.
• Solo código: restaura los archivos al estado elegido y mantiene la conversación intacta. Útil si quieres conservar el análisis y razonamiento de Claude pero deshacer los cambios en archivos.

El atajo Esc Esc abre el mismo menú de rebobinado sin teclear el comando.

Un aviso importante: solo se pueden revertir las operaciones de archivos que Claude haya hecho con sus herramientas oficiales. Los cambios que hagas manualmente en otro editor durante la sesión no están cubiertos.

Cómo controlar costes y rendimiento en Claude Code

Para controlar la relación coste-rendimiento en Claude Code, usa los comandos /cost, /model y /effort.

Si usas la API, el gasto en tokens importa. Si tienes planes Pro o Max, mantenerte dentro de tu cuota también. En cualquier caso, ejecutar siempre el modelo más potente con la máxima profundidad de razonamiento es un derroche.

/cost

/cost es un alias de /usage y muestra lo que has gastado hasta ahora:

• Para usuarios de API, muestra recuentos de tokens, uso de caché y coste en dólares desglosado por modelo. 
• Para suscriptores Pro y Max, muestra tu uso frente a la cuota del periodo de facturación.

Conviene consultar /cost al inicio de una sesión intensa para establecer una línea base y, de vez en cuando, en sesiones largas para ver a qué ritmo consumes presupuesto. 

Si los costes suben más rápido de lo esperado, los dos comandos siguientes son tus palancas.

/model

Cambiar el modelo activo con /model a mitad de sesión sin perder contexto es muy útil cuando cambian tus necesidades durante la sesión.

Si lo ejecutas sin argumentos, se abre un selector interactivo en el que navegas con las flechas. También puedes pasar el nombre del modelo directamente: /model claude-haiku-4-5.

Una estrategia práctica: 

1. Empieza la sesión con Claude Opus para razonamiento arquitectónico complejo
2. Luego cambia a Claude Sonnet para tareas de implementación
3. Baja a Claude Haiku para trabajo mecánico como renombrar variables, generar docstrings o completar boilerplate. 

La diferencia de coste entre Opus y Haiku es de unas 10 a 20 veces a escala.

Desde la v2.1.153, el modelo que selecciones con /model se guarda como predeterminado para sesiones nuevas. Pulsa s en el selector interactivo para aplicarlo solo a la sesión actual sin cambiar tu predeterminado.

/effort

Puedes decidir cuánta /effort emplea tu modelo y establecer la profundidad de razonamiento para el modelo actual. Sin argumentos, verás un control deslizante interactivo, pero también puedes fijarlo directamente, por ejemplo /effort low.

Los niveles disponibles son: 

• low

• medium

• high

• xhigh (abril de 2026)

• max (mayo de 2026)

• ultracode (mayo de 2026)

Los niveles max y ultracode son solo de sesión y no pueden guardarse como predeterminados. Usa /effort auto para restablecer al valor por defecto del modelo actual.

El nivel ultracode combina razonamiento xhigh con orquestación automática de flujos de trabajo para tareas multi‑paso muy complejas. Ojo, puede consumir muchos tokens, ya que la orquestación automática puede lanzar más de 100 agentes.

Regla práctica: 

• Usa low o medium para boilerplate, generación simple de código y refactors directos. 

• Reserva high o xhigh para depuración compleja, decisiones arquitectónicas y análisis multiarchivo donde acertar a la primera evita idas y vueltas. 

• Usa ultracode solo para grandes refactors, reescrituras de bases de código o tareas con muchas piezas en movimiento. 

El esfuerzo impacta directamente en la calidad y en el coste en tokens, así que calibrarlo a la tarea compensa.

Cómo crear comandos de barra personalizados en Claude Code

Los comandos integrados cubren lo fundamental a nivel operativo. Los comandos de barra personalizados son donde la herramienta empieza a sentirse propia.

La idea es simple: cualquier prompt que te descubras escribiendo a menudo se puede guardar como un archivo de comando e invocarlo con un simple /nombre-del-comando. La checklist estándar de code review de tu equipo, los pasos de verificación de despliegue de tu proyecto y tu forma preferida de pedir generación de tests pasan a ser compartibles. 

Comandos de barra vs skills de agente

Un aviso inicial: Anthropic ha unificado los comandos personalizados con las skills. El formato .claude/commands/ se considera legado. Sigue funcionando y la CLI lo seguirá soportando, pero el formato recomendado en adelante es .claude/skills/<name>/SKILL.md. 

Las skills admiten la misma invocación /name, Claude también puede invocarlas de forma autónoma cuando la descripción coincide con la tarea, y pueden incluir archivos de apoyo (scripts, plantillas, documentación) junto al prompt. 

Puedes leer más sobre skills en nuestro tutorial sobre Claude Skills.

Dónde viven los comandos personalizados

Los comandos personalizados son archivos Markdown guardados en dos ubicaciones posibles:

• A nivel de proyecto: .claude/commands/ dentro de la raíz del proyecto. Están acotados a ese proyecto, se pueden versionar y se comparten con cualquiera que trabaje en el mismo repo.

• Personales (globales): ~/.claude/commands/ en tu directorio de inicio. Están disponibles en todos los proyectos de tu máquina y son privados para ti.

El nombre de archivo sin la extensión .md pasa a ser el nombre del comando. Un archivo en .claude/commands/fix-issue.md crea /fix-issue. Un archivo en .claude/commands/frontend/component.md crea /component con una etiqueta de espacio de nombres indicando que viene del subdirectorio frontend.

Si prefieres usar el formato de skills, las rutas equivalentes son .claude/skills/<command-name>/SKILL.md para proyecto y ~/.claude/skills/<command-name>/SKILL.md para personal. El frontmatter y el cuerpo del prompt descritos abajo funcionan igual.

El formato del archivo

El cuerpo del archivo Markdown es la plantilla de prompt. Al invocar el comando, Claude lee el archivo, procesa las sustituciones y lo ejecuta como si hubieras escrito ese prompt tú mismo.

Aquí tienes un ejemplo mínimo para un archivo en .claude/commands/summarize-pr.md:

Review the current git diff and write a concise pull request description.
Include: what changed, why it changed, and any important implementation notes.
Format as plain prose, not bullet points.

Ejecuta /summarize-pr y Claude lanzará ese prompt contra la sesión actual.

Añadir frontmatter YAML

Para controlar mejor el comportamiento de un comando, añade frontmatter YAML al principio del archivo:

description: Generate a PR description from the current diff
allowed-tools: Bash(git diff *), Read
model: claude-sonnet-4-6

El frontmatter es importante por varios motivos:

• description aparece en el listado de /help para recordar qué hace el comando y para que Claude pueda asociarlo automáticamente cuando describes un caso de uso sin invocarlo explícitamente.

• Como su nombre indica, allowed-tools restringe qué herramientas puede usar Claude al ejecutar el comando, útil para limitar alcance y contexto. 

• Por último, model fija el comando a un modelo específico, independientemente del que esté activo en la sesión.

Usar $ARGUMENTS

El marcador $ARGUMENTS es lo que vuelve muy flexibles los comandos personalizados. Cualquier texto que escribas tras el nombre del comando se sustituye donde aparezca $ARGUMENTS en el prompt.

Aquí tienes un ejemplo completo. Vamos a crear un comando para arreglar incidencias del repo llamado .claude/commands/fix-issue.md:

---
description: Find and fix a GitHub issue by number
allowed-tools: Read, Edit, Bash(git diff *)
argument-hint: [issue-number]
---

Find and fix issue #$ARGUMENTS in this repository.

Steps:
1. Read the relevant source files to understand the current behavior
2. Identify the root cause
3. Implement the fix with minimal scope — do not change unrelated code
4. Verify the fix does not break anything obvious
5. Write a brief explanation of what changed and why

Lo invocas como /fix-issue 847 y Claude recibe el prompt completo con $ARGUMENTS sustituido por 847. También puedes usar argumentos posicionales $0, $1, etc., para comandos con varias entradas.

Inyectar salida del shell en vivo

Los comandos pueden inyectar salida en vivo del shell usando el prefijo !. Es útil para comandos que siempre deben operar sobre el estado actual:

allowed-tools: Read, Bash(git *)
description: Review staged changes before committing

Current staged diff:
!git diff --cached

Review these changes and suggest a clear, conventional commit message.
Flag any obvious bugs, missing tests, or incomplete logic before I commit.

Cuando Claude carga este comando, ejecuta primero git diff --cached, captura la salida y la inyecta en el prompt. Claude ve el diff real, no un marcador de posición.

Esta combinación de $ARGUMENTS, inyección de shell y frontmatter hace que los comandos personalizados de Claude Code sean una gran forma de acelerar tus prompts. 

Para más patrones y ejemplos reales, los tutoriales de DataCamp sobre buenas prácticas de Claude Code y Claude Code Hooks explican cómo estas herramientas encajan en flujos de trabajo de producción.

Reflexiones finales

Los comandos de barra no son funciones avanzadas reservadas a usuarios expertos. Son la capa operativa básica de Claude Code, y aprenderlos pronto cambiará tu forma de enfocar el desarrollo asistido por IA.

Si todo esto es nuevo para ti, empieza poco a poco. Incorpora /compact, /plan y /cost como formas pequeñas pero potentes de optimizar tus sesiones. Cuando te salgan de forma natural, añade /diff antes de los commits y /goal para cualquier tarea que dure más de unas pocas vueltas. El resto llegará cuando surjan las situaciones.

Para más ideas de comandos personalizados, te recomiendo seguir con nuestro tutorial de Claude Code Terminal. Si quieres una base sólida sobre cómo piensan los modelos Claude y para qué están diseñados, nuestros cursos Introduction to Claude Models y Claude Code 101 son el lugar idóneo para construirla.