Comandos slash (barra diagonal): Un / para invocar todos los accesos rápidos de Claude
📚 Navegación de la serie: El artículo anterior 35 Control y modos te enseñó cómo ajustar las riendas de Claude en la conversación (modos de permisos,
/model,/efforty otros interruptores). En este artículo nos enfocaremos en una herramienta que utilizas constantemente pero que tal vez no has investigado a fondo: los comandos slash (barra diagonal). Escribe un/y despliega la barra de control para alternar modelos, limpiar el contexto o ejecutar flujos de trabajo personalizados. Te mostraremos los comandos integrados y cómo crear los tuyos.
Muchos desarrolladores, al empezar a usar Claude Code, hicieron algo bastante absurdo.
Cada vez que querían limpiar la conversación para empezar de cero, realizaban este tedioso proceso: pulsar Ctrl+C para cerrar claude, escribir de nuevo claude en la terminal para iniciar, esperar a que cargara el proyecto y leyera CLAUDE.md (un proceso de unos diez segundos). Repitieron esta rutina durante una o dos semanas, pensando que al fin y al cabo "reiniciar era lo normal". Hasta que revisando la documentación oficial se toparon con el comando /clear, cuya descripción dice "inicia una nueva conversación con el contexto limpio". Fue entonces cuando se dieron cuenta de que bastaba con escribir tres caracteres en el chat, y que el tedioso proceso de reinicio había sido en vano.
Y lo peor vino después: descubrieron que /compact condensa las conversaciones largas para seguir charlando, /model cambia de modelo en caliente sin reiniciar la consola, e /init genera el archivo CLAUDE.md de forma automática... todas ellas acciones que antes realizaban a mano o desconocían por completo. Estos comandos siempre estuvieron disponibles en el menú de / al pulsar la barra diagonal, pero nunca los habían revisado.
Te contamos esta anécdota para evitarte dar rodeos: los comandos slash no son características avanzadas; son el panel de control básico de Claude Code. Casi cualquier acción técnica que quieras realizar sobre el chat (no pedirle código, sino configurar la aplicación) tiene su punto de acceso en el símbolo /. En este artículo te mostraremos las opciones integradas y cómo crear tus propios comandos rápidos.
Al terminar de leer este artículo, obtendrás:
- Qué son los comandos slash y por qué solo se reconocen si se escriben al principio del mensaje.
- La lista de comandos integrados clasificados por su caso de uso (
/help,/clear,/compact,/init,/model,/agents,/mcp,/memory, etc.) para consultarlos fácilmente. - Cómo escribir un comando personalizado en tres pasos: crear un archivo Markdown en
.claude/commands/, añadir frontmatter y usar la variable$ARGUMENTSpara los parámetros. - Un truco avanzado: cómo inyectar información dinámica (como un
git diff) en el comando antes de enviarlo a Claude. - Qué son los espacios de nombres y por qué evitan que los comandos de los plugins entren en conflicto con los tuyos.
- La relación real entre los comandos slash y los Skills (resumen: un comando slash es la activación manual de un Skill; ver detalles en el artículo 26).
- Un ejercicio práctico paso a paso: crear un comando personalizado
/explaincon parámetros y comprobar su funcionamiento en 5 minutos.
01 Concepto base: Qué es un comando slash y por qué solo actúa al principio
Empecemos con la conclusión: los comandos slash son las "directrices de control" que escribes en la conversación; no se dirigen a Claude para asignarle trabajo, sino que ordenan al software Claude Code realizar una acción: alternar el modelo, limpiar la memoria, ejecutar un proceso o desplegar un panel.
A lo largo de la serie hemos clasificado las peticiones en dos tipos. Por un lado, las tareas de desarrollo: "ayúdame a refactorizar esta función" o "¿a qué se debe este error?" (dirigidas al modelo de IA). Por otro lado, las acciones del entorno: "limpia la conversación", "usa un modelo más económico" o "crea un resumen de este archivo". Para estas últimas no tiene sentido entablar una conversación, sino disponer de interruptores directos. Los comandos slash son el acceso unificado a estos interruptores.
Analogía: Los botones del mando a distancia de la televisión. Para encender, cambiar de canal, ajustar el volumen o acceder al menú, no le hablas a la televisión explicándole qué quieres; pulsas el botón correspondiente. Cada botón ejecuta una acción fija predefinida de forma inmediata, sin interpretaciones ni errores. Los comandos slash son los botones de Claude Code: /clear es el botón de limpiar pantalla, /model es el selector de canal (modelo) y /help abre el menú. Se ejecutan como lógica directa de la aplicación, independientemente de la IA.
La documentación oficial define su posición:
Los comandos controlan el funcionamiento de Claude Code desde la conversación. Proporcionan una vía rápida para cambiar de modelo, gestionar permisos, limpiar el contexto, ejecutar flujos de trabajo, etc.
Aquí hay un detalle muy importante a tener en cuenta: los comandos slash solo se reconocen al principio del mensaje.
...
Los comandos solo se reconocen al principio de un mensaje. El texto posterior al nombre del comando se le pasa como argumento.
Es decir, el símbolo / debe ser el primer carácter de tu mensaje para que la consola lo interprete como comando. Si escribes "ayúdame a ver qué hace /clear", la palabra /clear se sitúa en medio de la frase, por lo que no se ejecutará y se enviará a Claude como texto plano. Esto es un diseño inteligente para evitar que al debatir sobre un comando en el chat (como al hablar de /clear), la sesión se cierre por accidente. Regresa a esta regla: el comando al principio, y los parámetros detrás.
Piensa en estas situaciones de uso cotidiano:
- Notas que el modelo actual no resuelve la tarea → Sin cerrar la sesión, escribe
/modely cambia a un modelo más potente en caliente. - Has terminado una tarea y vas a empezar otra diferente → Escribe
/clearpara limpiar el espacio de trabajo; podrás recuperar el chat anterior con/resume. - Acabas de clonar un repositorio y quieres que Claude lo analice → Escribe
/initpara que lea el código y genere el archivoCLAUDE.md.
Todas estas acciones tienen en común que no implican programar, sino gestionar el comportamiento de Claude Code. Ese es el ámbito de los comandos slash.
¿Cómo ver los comandos disponibles? Sencillo: escribe / en el chat y se desplegará el menú con todas las opciones disponibles; escribe letras a continuación para filtrar la lista sobre la marcha. Palabras oficiales:
Escribe
/para ver la lista de comandos disponibles, o introduce letras a continuación para filtrar las opciones.
💡 Resumen en una frase: Los comandos slash son los "botones de control" de Claude Code: gestionan el software directamente (cambiar modelo, limpiar chat, flujos de trabajo) sin pasar por la IA. Solo se interpretan si se escriben al principio del mensaje, y basta con teclear
/para ver la lista completa.
02 Lista de comandos integrados: Consulta según tu flujo de trabajo
Claude Code cuenta con decenas de comandos. Intentar memorizarlos todos no es eficiente. La propia documentación oficial los organiza según las fases habituales de una conversación. Busca la fase en la que te encuentras y consulta las opciones disponibles.
Aclaración de formato: la mayoría de opciones son comandos integrados (acciones programadas directamente en la CLI que ejecutan una lógica fija), pero verás otras clasificadas como Skill (Skills empaquetados, que en realidad son prompts que guían a Claude para usar sus herramientas, como /code-review o /debug) o como Workflow (flujos de trabajo dinámicos multiagente, como /batch o /deep-research). En la práctica se invocan igual escribiendo /nombre; la diferencia es interna y la explicamos en el artículo 26.
Grupo 1: Configurar el espacio de trabajo (al iniciar el desarrollo)
| Comando | Función | Cuándo usarlo |
|---|---|---|
/init | Genera un archivo CLAUDE.md de partida en el proyecto | Al abrir Claude por primera vez en un repositorio (ver artículo 12) |
/memory | Modifica el archivo CLAUDE.md y gestiona la memoria automática | Para ajustar el contexto de la base de código (ver artículo 25) |
/mcp | Administra las conexiones y permisos de MCP | Para conectar con bases de datos o servicios externos (ver artículo 22) |
/agents | Configura los subagentes (subagents) | Para asignar tareas a asistentes secundarios (ver artículo 23) |
/permissions | Gestiona las reglas de permisos (allow / ask / deny) | Para definir cuándo se piden confirmaciones (ver artículo 20) |
Este grupo conforma el flujo de inicio habitual en un nuevo proyecto: ejecutas /init para generar el borrador de CLAUDE.md y luego usas /memory para corregir detalles. Te evita tener que estructurar el archivo de instrucciones desde cero, lo cual es muy cómodo.
Grupo 2: Controlar la sesión (durante el desarrollo)
| Comando | Función | Cuándo usarlo |
|---|---|---|
/model | Alterna el modelo de la conversación y lo establece por defecto | Para cambiar a un modelo más potente o más económico |
/clear | Limpia el contexto iniciando un nuevo chat (el anterior se guarda en /resume) | Para cambiar a una tarea totalmente distinta con el chat limpio |
/compact | Resume la conversación actual para liberar espacio de contexto | El chat es muy largo y el contexto está al límite (ver artículo 19) |
/context | Muestra la distribución del contexto en una rejilla de color | Para inspeccionar qué archivos consumen más espacio |
/plan | Activa el Plan Mode (modo planificación) | Para pedir un plan de acción sin modificar código |
Distingue bien /clear y /compact (una confusión común en la gestión de contexto). Regla rápida: si vas a iniciar una tarea distinta, usa /clear (limpia la pizarra por completo); si continúas con la misma tarea pero la conversación es muy larga, usa /compact (resume los pasos anteriores y sigue en el mismo chat). Detallamos esto en el artículo 19.
Grupo 3: Validar el trabajo (antes de confirmar cambios)
| Comando | Función |
|---|---|
/diff | Abre un visualizador interactivo de diferencias de git |
/review | Realiza una revisión de un Pull Request en el chat |
/security-review | Busca fallos y vulnerabilidades de seguridad en los cambios |
/code-review | Analiza el diff buscando bugs o mejoras (admite --fix para aplicar correcciones) |
Grupo 4: Utilidades y mantenimiento
| Comando | Función |
|---|---|
/help | Muestra la ayuda y los comandos disponibles |
/config | Abre el menú de configuración (tema, modelo, estilo de salida...) |
/doctor | Inspecciona el estado de la instalación y corrige fallos de forma automática pulsando f |
/resume | Abre un selector para reanudar una conversación previa |
/skills | Muestra la lista de Skills disponibles en la conversación |
/rewind | Revierte el código y la conversación a un checkpoint previo (tema del próximo artículo) |
Nota: la lista de comandos disponibles puede variar según tu cuenta, plan o sistema operativo. Por ejemplo, /desktop solo se muestra en macOS y Windows usando suscripción de Claude, y /upgrade solo está disponible en planes Pro y Max. El menú de / en tu consola te mostrará los comandos reales que puedes usar en ese momento.
Esta lista recoge el 90% de tus necesidades en el día a día. Si necesitas una opción específica, escribe / y filtra con el teclado.
💡 Resumen en una frase: Organiza los comandos según tu flujo: inicio (
/init,/memory,/permissions), desarrollo (/model,/clear,/compact), validación (/diff,/code-review) y utilidades (/help,/doctor,/resume); pulsa/para ver el catálogo real en tu máquina.
03 Crear tu propio comando: Archivos Markdown en .claude/commands/
Conocer las opciones del sistema está muy bien, pero el verdadero potencial radica en poder crear tus propios comandos.
¿Por qué querrías hacerlo? Piensa en las instrucciones que repites a Claude: indicarle el formato de los commits, el tono de las revisiones de código o pedirle que no use tecnicismos al explicar. Si repites un prompt por quinta vez, es señal de que debes estructurarlo como un comando.
Analogía: El botón programable del mando de la televisión. Los mandos avanzados disponen de un botón que permite grabar secuencias (encender la tele → cambiar al canal de entrada HDMI2 → ajustar el volumen a 15). En lugar de pulsar tres botones, pulsas uno. Un comando personalizado hace lo mismo: graba un prompt repetitivo para que lo ejecutes escribiendo su nombre, simplificando tu interacción.
¿Cómo se diseña? Es sumamente sencillo: crea un archivo Markdown en la carpeta .claude/commands/ y el nombre del archivo definirá el comando. La documentación oficial lo detalla:
El archivo en
.claude/commands/deploy.mdcreará el comando/deploy.
Es decir, si creas el archivo .claude/commands/commit.md e introduces tus reglas de confirmación de código, se creará automáticamente el comando /commit. El nombre del archivo (sin la extensión .md) define el comando, sin más configuraciones.
Veamos un ejemplo sencillo. Creas el archivo .claude/commands/review.md con este contenido:
Por favor, revisa mis cambios no confirmados centrándote en tres aspectos:
1. Comprueba si falta control de errores en las nuevas funciones.
2. Identifica si hay configuraciones escritas en duro (puertos, claves, rutas).
3. Comprueba si es necesario añadir pruebas unitarias.
Escribe el resultado en español estructurado por archivos.Una vez guardado, escribe /review en el chat y Claude leerá estas instrucciones como si las hubieras escrito tú en ese momento, resolviendo la tarea con solo siete caracteres.
Ten presente dónde guardar el archivo, siguiendo la lógica de la serie:
| Ruta | Ámbito | ¿Se sube a git? |
|---|---|---|
Proyecto .claude/commands/ | Exclusivo de este repositorio | Sí, se comparte con el equipo |
Personal ~/.claude/commands/ | Disponible en todos tus repositorios | No, es exclusivo de tu máquina |
La regla es idéntica a la de los Skills: si el comando es específico de las convenciones de un proyecto (como las normas de despliegue del equipo), colócalo a nivel de proyecto para compartirlo en git; si responde a tus hábitos de desarrollo individuales (como tu tono de revisión preferido), guárdalo en tu carpeta personal ~/.claude/commands/ para tenerlo disponible en todos tus proyectos.
💡 Resumen en una frase: Para crear un comando personalizado, añade un archivo Markdown en
.claude/commands/(el nombre del archivo define el comando slash); colócalo a nivel de proyecto para compartirlo con el equipo o en~/.claude/commands/para tu uso personal global.
04 Configuración avanzada: frontmatter y el parámetro $ARGUMENTS
El comando /review anterior es funcional, pero estático: no admite parámetros. No puedes indicarle "revisa solo el archivo src/auth.ts", por lo que siempre analizará todos los cambios. Para dar dinamismo al comando, añadiremos dos elementos: metadatos en el frontmatter y variables de parámetros.
Uso de $ARGUMENTS para capturar parámetros
Claude Code dispone del marcador $ARGUMENTS: el texto que escribas a continuación del comando en el chat se inyectará en la posición de esta variable. La documentación oficial muestra este ejemplo:
Fix GitHub issue $ARGUMENTS following our coding standards.
1. Read the issue description
2. Understand the requirements
3. Implement the fixLa documentación explica su funcionamiento:
Al escribir
/fix-issue 123, Claude recibirá: "Fix GitHub issue 123 following our coding standards..."
La variable $ARGUMENTS se sustituye por 123. El comando actúa como plantilla y tú defines el valor en caliente; esta es la base de su versatilidad.
Nota: si pasas parámetros en la llamada pero tu archivo Markdown no incluye la variable $ARGUMENTS, Claude Code añadirá la línea ARGUMENTS: <tus parámetros> al final de la instrucción automáticamente para evitar que la información se pierda.
Capturar parámetros por su posición con $0, $1
Si necesitas pasar múltiples argumentos independientes (por ejemplo: "migra el componente SearchBar de React a Vue"), puedes capturarlos por su posición usando $ARGUMENTS[N] o de forma abreviada $N (comenzando en 0):
Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.Al ejecutar /migrate-component SearchBar React Vue, $0 tomará el valor SearchBar, $1 tomará React y $2 tomará Vue. Detalle importante: la separación sigue la sintaxis de shell, por lo que si un argumento contiene varias palabras, debes escribirlo entre comillas. Si escribes /my-cmd "hola mundo" segundo, $0 tomará el valor hola mundo; si omites las comillas, los términos se tratarán como argumentos independientes (separados por espacios). $ARGUMENTS no tiene esta restricción y captura todo el bloque de texto tal cual se introduce.
Configurar el comportamiento con frontmatter
Podemos configurar el comportamiento del comando usando el frontmatter (los metadatos delimitados por --- al principio del archivo que estudiamos para los Skills en el artículo 26). Las opciones más útiles son:
---
description: Prepara y confirma los cambios actuales
disable-model-invocation: true
---
Confirma los cambios actuales en git con un mensaje normalizado en español:
1. Ejecuta las pruebas del proyecto.
2. Añade los cambios con git add.
3. Confirma con un mensaje estructurado como feat/fix/docs.description: describe la función del comando. Sirve para que Claude evalúe cuándo activarlo de forma automática, por lo que es recomendable definirlo siempre.disable-model-invocation: true: impide que Claude active este comando por su cuenta, limitando su uso a tu invocación manual. Configúralo en comandos con efectos secundarios (despliegues, commits, envío de alertas) donde quieras tener el control del momento de disparo.
Recuerda esta regla para evitar sorpresas: por defecto, tus comandos personalizados pueden ser activados tanto por ti como por Claude. Claude lee la description y, si la tarea coincide, puede decidir ejecutar el comando. Para evitarlo, usa disable-model-invocation: true en comandos críticos. Es una buena medida para comandos de confirmación o despliegue.
| Objetivo de la configuración | Opción en frontmatter |
|---|---|
| Evitar que Claude ejecute el comando por su cuenta | disable-model-invocation: true |
| Explicar a Claude cuándo usarlo automáticamente | description: "..." |
| Definir permisos rápidos para el comando sin preguntar | allowed-tools: Bash(git add *) Bash(git commit *) |
💡 Resumen en una frase:
$ARGUMENTSinyecta todo el texto posterior al comando;$0,$1capturan parámetros individuales (usa comillas para agrupar palabras); el frontmatterdescriptionayuda a la activación automática de Claude ydisable-model-invocation: truerestringe el comando a ejecución manual.
05 Inyección dinámica de contexto: Datos en tiempo real en tus comandos
Podemos llevar los comandos un paso más allá: hacer que recopilen datos en tiempo real antes de enviar la instrucción a Claude. Esta técnica se conoce como inyección dinámica de contexto (dynamic context injection).
Su utilidad: en el comando /review anterior, pedimos revisar los cambios no confirmados, por lo que Claude debe ejecutar comandos en Bash para obtener el diff de git. Con la inyección dinámica, podemos pasarle el diff directamente al cargar el comando.
La sintaxis consiste en escribir !`comando` (un símbolo de exclamación seguido del comando en comillas invertidas). La documentación oficial lo detalla:
La sintaxis
!`<command>`ejecuta el comando de shell antes de enviar la instrucción a Claude. La salida del comando reemplaza la variable, por lo que Claude recibe los datos reales directamente.
Si actualizamos el comando /review de .claude/commands/review.md con esta técnica:
## Cambios actuales
!`git diff HEAD`
## Instrucciones
Revisa los cambios anteriores buscando fallos de seguridad, claves en duro o falta de pruebas. Escribe el resultado en español.¿Qué ocurre al ejecutar /review? El flujo de ejecución es el siguiente:
- Claude Code ejecuta el comando
git diff HEADen tu máquina. - Reemplaza la línea del archivo con la salida del comando.
- Envía el prompt a Claude con el diff real ya inyectado.
Claude no necesita ejecutar herramientas para leer el diff; lo recibe directamente en el prompt de entrada. Se procesa antes de enviar el mensaje, por lo que Claude actúa directamente sobre la información.
Detalles técnicos a tener en cuenta:
- El símbolo de exclamación debe ir al principio de la línea o después de un espacio en blanco para ser detectado. Si escribes
DIF=!git diff, no se interpretará como comando y se tratará como texto plano. - Para comandos de múltiples líneas, utiliza un bloque de código Markdown que empiece con
```!(escribiendo cada comando en una línea). - Esta característica puede desactivarse por seguridad. Si estableces
disableSkillShellExecution: trueen tu configuración, se anulará la ejecución de estos comandos mostrando la advertencia[shell command execution disabled by policy]. Es de utilidad en entornos administrados de equipo para evitar que un repositorio clonado ejecute comandos sospechosos en segundo plano.
Puedes complementar el comando añadiendo argument-hint en el frontmatter (por ejemplo, argument-hint: [numero-de-issue]) para que la consola muestre una ayuda sobre qué parámetro pasar al escribir el comando.
💡 Resumen en una frase: Escribir
!`comando`ejecuta la orden en tu máquina e inyecta el resultado en el prompt antes de enviarlo a Claude; debe escribirse al inicio de línea (o en bloques```!para varias líneas) y puede desactivarse globalmente por seguridad condisableSkillShellExecution: true.
06 Espacios de nombres en plugins: Evitar conflictos
Al crear muchos comandos personalizados o instalar plugins externos, surge la duda: ¿qué ocurre si coinciden en el nombre? Por ejemplo, si creas un comando /review y un plugin instalado también incluye un comando /review.
La resolución de conflictos depende del origen de las herramientas:
Conflictos con tus propios Skills: Prioridad del Skill
Si un comando en .claude/commands/ coincide en nombre con un Skill en .claude/skills/, la regla oficial determina:
Si un skill y un comando personalizado comparten el mismo nombre, el skill tiene prioridad.
Es decir, al escribir /deploy se ejecutará el Skill definido en .claude/skills/deploy/SKILL.md sobre el comando de .claude/commands/deploy.md. Diseña nombres distintos para evitar confusiones.
Conflictos con plugins externos: Espacios de nombres aislados
Los plugins resuelven este problema de raíz: no entran en conflicto con tus nombres. La documentación oficial lo detalla:
Los skills de plugins utilizan el espacio de nombres
nombre-del-plugin:nombre-del-skill, por lo que no colisionan con los otros niveles de configuración.
Analogía: Añadir un prefijo en la agenda. Si tienes dos amigos llamados "Carlos", los registrarás como "Carlos (Trabajo)" y "Carlos (Gimnasio)". El prefijo evita que los confundas. Los plugins hacen lo mismo: el comando review del plugin my-plugin se invocará en tu consola como /my-plugin:review. Aunque tengas tu propio comando /review, al estar el del plugin aislado por su prefijo, no habrá interferencias.
De esta forma, las herramientas de los plugins se invocan como /nombre-del-plugin:nombre-del-skill (artículo 24). Si instalas dos plugins con la función review, se llamarán /plugin-a:review y /plugin-b:review respectivamente.
También verás comandos con doble guion bajo: son los prompts expuestos por servidores MCP. Se estructuran como /mcp__<servidor>__<prompt> al conectarse con el servidor MCP (ver artículo 22).
💡 Resumen en una frase: En caso de coincidencia local, los Skills tienen prioridad sobre los comandos personalizados; las herramientas de los plugins evitan colisiones usando espacios de nombres (
nombre-del-plugin:nombre-del-comando), y las de MCP usan el prefijo/mcp__.
07 Relación entre comandos slash y Skills
Al estudiar ambas herramientas, verás que son muy similares: ambas sirven para empaquetar instrucciones para Claude. ¿Qué diferencia hay entre escribir un comando en .claude/commands/ y un SKILL.md en .claude/skills/?
Ambos mecanismos forman parte del mismo sistema de Skills de Claude Code. Crear un comando en .claude/commands/ es la vía simplificada, mientras que un Skill es la arquitectura avanzada:
Los comandos personalizados se han fusionado en el sistema de skills. El archivo en
.claude/commands/deploy.mdy el skill en.claude/skills/deploy/SKILL.mdcrearán/deployy funcionarán de la misma manera.
No son herramientas opuestas, sino dos formas de estructurar el mismo recurso. Podemos resumirlo de esta forma: el comando slash es la "vía de invocación" (llamar escribiendo /) y el Skill es "el recurso empaquetado". Comparamos sus características en esta tabla de diseño:
| Criterio | Comando personalizado (commands/xx.md) | Skill (skills/xx/SKILL.md) |
|---|---|---|
| Complejidad | Un único archivo Markdown, muy sencillo | Carpeta estructurada con archivos de soporte |
| Recursos adicionales | No admite plantillas ni scripts | Admite plantillas, ejemplos y scripts de consola |
| Activación automática | Sí, según su description | Sí, optimizado para ello (ver artículo 26) |
| Carga en el contexto | Se lee por completo al invocarlo | El texto principal se lee al usarlo; los documentos de apoyo se cargan bajo demanda |
Regla de diseño: para prompts sencillos de un solo archivo que quieres invocar manualmente (como nuestro /review), crea un archivo Markdown en .claude/commands/; es la vía más rápida. Si necesitas añadir scripts de ejecución, plantillas de salida o documentaciones de consulta extensas que no deben saturar el inicio de la conversación, crea un Skill (artículos 26 y 27, o ayúdate de skill-creator en el artículo 28).
Ambos sistemas conviven de forma oficial; el directorio .claude/commands/ se mantiene plenamente operativo para estructurar tus accesos rápidos de forma ágil.
💡 Resumen en una frase: Los comandos personalizados están integrados en el sistema de Skills; la carpeta
.claude/commands/es la vía ágil para prompts sencillos, y el formato de carpeta de los Skills se reserva para flujos avanzados con scripts o plantillas. Ambos se invocan escribiendo/nombre.
08 Práctica: Crear el comando personalizado /explain con parámetros
Pasemos a la práctica. Crearemos un comando personalizado que reciba parámetros para explicar fragmentos de código en lenguaje sencillo, validando su funcionamiento en una carpeta de pruebas.
Paso 1: Crear la carpeta de comandos (en tu terminal)
Accede a un directorio de pruebas (puedes crear uno vacío) y genera la carpeta de comandos:
mkdir -p .claude/commandsUsuarios de Windows: cread la carpeta .claude\commands\ desde el explorador o consola en la raíz de tu carpeta de pruebas.
Resultado esperado: se ha creado la ruta .claude/commands/.
Paso 2: Escribir el archivo del comando
Crea el archivo .claude/commands/explain.md e introduce la siguiente configuración:
---
description: Explica un fragmento de código o error en lenguaje sencillo
---
Por favor, explica el siguiente elemento en lenguaje sencillo para un principiante:
$ARGUMENTS
Instrucciones:
1. Explica en una frase qué hace en general.
2. Desglosa los componentes clave en pasos sencillos.
3. Si se trata de un error, detalla por qué ocurre y cómo solucionarlo.
4. Evita los tecnicismos complejos y usa analogías cotidianas si ayuda.Nota los dos elementos: la description en el frontmatter para documentar el comando, y la variable $ARGUMENTS en el cuerpo para capturar el texto que pasemos en el chat.
Resultado esperado: has guardado el archivo explain.md en el directorio.
Paso 3: Iniciar la conversación y verificar el comando en el menú
claudeUna vez dentro, escribe el carácter / (sin pulsar Enter) y revisa la lista del menú:
Resultado esperado: el menú mostrará /explain con la descripción que configuramos en el frontmatter. Verlo en el menú confirma que Claude Code ha detectado y cargado el comando. Si no aparece, comprueba que la ruta al archivo es la correcta.
Paso 4: Ejecutar el comando pasándole un código como parámetro
Escribe el comando y añade un fragmento de código a continuación (esta cadena se inyectará en la variable $ARGUMENTS):
/explain print(sum([1,2,3]) / len([1,2,3]))Resultado esperado: Claude ejecutará el comando inyectando el código en $ARGUMENTS, y te devolverá la explicación siguiendo los cuatro puntos: resumen en una frase (calcular el promedio), desglose de pasos, tono sencillo y analogía. Has ejecutado un prompt de formato complejo pasando el parámetro en una línea.
Paso 5: Probar con un parámetro de error
Usa el mismo comando pero pasando un mensaje de error como argumento:
/explain ZeroDivisionError: division by zeroResultado esperado: se ejecuta la misma plantilla, pero al ser el argumento un error, Claude se enfocará en el punto 3 (explicando la división por cero y cómo corregirla). La plantilla se adapta al parámetro que introduzcas en cada llamada, superando la rigidez de las instrucciones estáticas.
Con este ejercicio habrás comprobado el flujo de comandos personalizados: crear el archivo .md, documentarlo con frontmatter, capturar argumentos con $ARGUMENTS y ejecutar con parámetros. Diseñar tus comandos seguirá este mismo proceso.
💡 Resumen en una frase: Crea un comando de prueba: crea la carpeta
.claude/commands/→ escribeexplain.mdcon sudescriptiony la variable$ARGUMENTS→ inicia Claude y comprueba que aparece en el menú de/→ ejecútalo pasando diferentes códigos como parámetros; comprobar cómo se adapta la respuesta te mostrará el potencial de los comandos dinámicos.
09 Resumen
En este artículo hemos explorado los comandos slash como paneles de control y accesos rápidos en Claude Code.
Repasemos las ideas explicadas:
| Aspecto | Comportamiento / Sintaxis | Detalle clave |
|---|---|---|
| Qué son | Instrucciones de control del software | Gestionan la aplicación en caliente; solo se reconocen al inicio del mensaje. |
| Comandos del sistema | Catálogo de herramientas | Organizados por fases: inicio (/init, /memory), control (/model, /clear), validación (/code-review). |
| Crear comandos propios | Archivos Markdown de prompt | Colocados en .claude/commands/ (Proyecto) o ~/.claude/commands/ (Usuario). |
| Capturar parámetros | Variable $ARGUMENTS | Inyecta el texto posterior en la plantilla; admite $0, $1 para argumentos por posición. |
| Inyectar datos dinámicos | Sintaxis !`comando` | Ejecuta una orden de consola e inyecta la salida en el prompt antes de enviarlo. |
| Configurar ejecución | Frontmatter del comando | disable-model-invocation: true para restringir el comando a disparo manual. |
| Resolución de colisiones | Espacios de nombres | Los Skills locales tienen prioridad sobre los comandos; los plugins usan plugin-name:skill-name. |
Ahora deberías ser capaz de: navegar por la lista de comandos integrados usando /, decidir qué comandos aplicar según la fase de desarrollo, crear tus propios comandos slash usando Markdown, definir argumentos de entrada simples y múltiples, inyectar salidas de consola dinámicas en tus prompts, y estructurar la seguridad del comando con frontmatter. Saber usar y diseñar comandos slash te permite simplificar tareas y consolidar tus prompts frecuentes en accesos directos de consola.
En lugar de salir de la aplicación o reescribir instrucciones complejas, revisa si existe un comando slash o crea uno en un par de minutos para optimizar tu flujo de trabajo.
En el próximo artículo, 37 "Checkpoints (Puntos de control)", profundizaremos en el control de cambios en el código. Mencionamos el comando /rewind en este artículo, indicando que permite revertir el código a estados previos. En la siguiente sección explicaremos detalladamente cómo gestiona Claude Code los checkpoints, qué herramientas de git utiliza en segundo plano, cómo interactuar con el menú interactivo de restauración y cómo te ayuda a probar soluciones sin temor a romper el repositorio. Piensa en esto: ¿cuántas veces has tenido que deshacer cambios manualmente tras una prueba fallida con la IA? Lo veremos en el próximo artículo.