Claude Code: 15 comandos útiles

Slash commands nativos

Claude Code (Anthropic) incluye slash commands que puedes ejecutar en cualquier momento. No son prompts: son comandos del sistema que controlan la sesión.

/help      # Muestra ayuda completa
/clear     # Limpia la conversación (nuevo contexto)
/compact   # Comprime el contexto (ahorra tokens)
/cost      # Muestra cuánto has gastado en la sesión
/memory    # Ver/editar memoria persistente
/model     # Cambiar de modelo (Opus, Sonnet, Haiku)
/fast      # Toggle modo rápido (mismo modelo, output más rápido)
/plan      # Modo planificación (diseña antes de ejecutar)
/review    # Revisa los cambios pendientes
/init      # Genera un CLAUDE.md inicial para tu proyecto
/login     # Autenticar con tu cuenta de Anthropic
/logout    # Cerrar sesión
/doctor    # Diagnostica problemas de configuración
/permissions # Gestionar permisos de herramientas

Cada slash command tiene un propósito específico. Los más importantes para el día a día son /compact, /clear, /cost y /model.

/model merece atención especial. Claude Code permite cambiar de modelo durante la sesión:

• Opus: el modelo más capaz. Para tareas que requieren razonamiento profundo, arquitectura compleja o código con muchas dependencias. Consume más tokens.
• Sonnet: el equilibrio. Rápido, capaz, económico. Es el modelo por defecto y el recomendado para el 80% de las tareas.
• Haiku: el más rápido y barato. Para tareas simples: formateo, clasificación, preguntas rápidas. No lo uses para refactoring complejo.

La estrategia óptima: empieza con Sonnet, cambia a Opus cuando necesites razonamiento profundo, y usa Haiku para tareas simples de mantenimiento.

Ejecutar comandos del sistema

Con el prefijo ! puedes ejecutar cualquier comando de tu terminal sin salir de Claude Code:

! git status          # Ver estado del repo
! npm test            # Ejecutar tests
! docker ps           # Ver contenedores
! ls -la src/         # Listar archivos
! cat package.json    # Ver un archivo
! python script.py    # Ejecutar script
! curl -s api.com/v1  # Hacer petición HTTP
! wc -l src/**/*.py   # Contar líneas de código

El resultado aparece directamente en la conversación. Claude Code lo ve y puede actuar en consecuencia. Esto es especialmente potente para debugging: ejecutas un comando, Claude Code lee el output y sugiere el siguiente paso.

Ejemplo práctico de debugging con !:

# Tú: "Los tests fallan, no sé por qué"
! npm test
# Claude Code lee el output de error y responde:
# "El test de auth.test.js falla en línea 42.
#  El mock de jwt.verify no está configurado.
#  Voy a añadir el mock..."

El prefijo ! ejecuta el comando y muestra el resultado en el contexto de la conversación. Claude Code puede entonces razonar sobre el output y proponer acciones. Es más eficiente que copiar/pegar desde otra terminal.

Crear comandos personalizados

Lo más potente de Claude Code: crear tus propios slash commands. Se guardan como archivos markdown en .claude/commands/:

# .claude/commands/review-pr.md
Revisa el PR actual. Busca:
1. Bugs o errores lógicos
2. Vulnerabilidades de seguridad (OWASP Top 10)
3. Tests faltantes
4. Problemas de rendimiento
Formato: lista priorizada por severidad.

Ahora escribes /review-pr en Claude Code y ejecuta ese prompt. Puedes pasar argumentos con $ARGUMENTS:

# .claude/commands/explain.md
Explica el archivo $ARGUMENTS de forma concisa:
- Qué hace
- Dependencias principales
- Puntos de atención

# Uso: /explain src/api/auth.py

Los comandos custom son la funcionalidad más infravalorada de Claude Code. Convierten prompts repetitivos en funciones reutilizables. Estos son algunos ejemplos que se usan habitualmente:

# .claude/commands/commit.md
Analiza los cambios staged (git diff --cached).
Genera un commit message siguiendo Conventional Commits:
- tipo(scope): descripción breve
- Cuerpo con contexto si es necesario
Ejecuta el commit.

# .claude/commands/test-coverage.md
Ejecuta los tests con cobertura.
Identifica los 5 archivos con menor cobertura.
Para cada uno, sugiere qué tests añadir.

# .claude/commands/security-check.md
Revisa el código del directorio $ARGUMENTS buscando:
1. Secrets hardcodeados (API keys, tokens, passwords)
2. SQL injection
3. XSS vulnerabilities
4. Dependencias con CVEs conocidos
Ejecuta: npm audit o pip audit según el proyecto.

# .claude/commands/daily-standup.md
Resume el trabajo del último día:
1. git log --since="yesterday" --oneline
2. Issues asignados a mí en GitHub
3. PRs pendientes de review
Formato: bullet points para standup meeting.

Organización de comandos. A medida que creas más comandos, organízalos por dominio. Puedes crear subdirectorios dentro de .claude/commands/:

.claude/commands/
├── dev/
│   ├── commit.md
│   ├── test-coverage.md
│   └── refactor.md
├── security/
│   ├── security-check.md
│   └── dependency-audit.md
├── content/
│   ├── seo-article.md
│   └── social-post.md
└── ops/
    ├── daily-standup.md
    └── deploy-check.md

Atajos de teclado

Claude Code responde a varios atajos de teclado que aceleran el flujo de trabajo:

Ctrl+C     # Cancelar la operación actual (sin salir)
Ctrl+D     # Salir de Claude Code
Esc        # Cancelar la edición del prompt actual
Tab        # Autocompletar rutas de archivos en el prompt
Shift+Tab  # Autocompletar inverso
Up/Down    # Navegar historial de prompts anteriores
Ctrl+L     # Limpiar pantalla (equivale a /clear visual)

El más importante es Ctrl+C. Si Claude Code está ejecutando una tarea larga (refactoring de 50 archivos) y quieres pararlo, Ctrl+C cancela la operación actual sin perder el contexto de la sesión. Es diferente de Ctrl+D, que cierra la sesión completamente.

Historial de prompts. Las flechas Up/Down navegan por tus prompts anteriores en la sesión. Esto es especialmente útil cuando iteras sobre un prompt: lo ejecutas, ves el resultado, subes con Up, lo modificas y lo ejecutas de nuevo.

Flags de línea de comandos

Claude Code acepta flags al iniciarlo que cambian su comportamiento. Los más útiles:

# Ejecutar un prompt sin sesión interactiva
claude --print "genera un .gitignore para Python"

# Continuar la última sesión
claude --resume

# Iniciar con un prompt específico
claude "analiza este repo y dame un resumen"

# Pasar un archivo como contexto
cat error.log | claude "explica estos errores"

# Especificar el modelo desde el inicio
claude --model opus "diseña la arquitectura de este servicio"

# Modo no interactivo con output a archivo
claude --print "genera el schema SQL" > schema.sql

# Usar un directorio diferente
claude --cwd /path/to/project "ejecuta los tests"

# Activar modo verbose para debugging
claude --verbose

El flag más infravalorado: --print. Ejecuta un prompt y devuelve solo el output, sin interfaz interactiva. Es perfecto para scripts, pipelines CI/CD y automatización. Ejemplo de uso en un script bash:

#!/bin/bash
# Script: daily-report.sh
REPORT=$(claude --print "resume los commits de hoy: $(git log --since=today --oneline)")
echo "$REPORT" | slack-post --channel #dev-updates

Encadenar comandos

Una técnica avanzada: encadenar múltiples acciones en un solo prompt. Claude Code entiende instrucciones secuenciales:

# Encadenamiento simple
"Lee src/api/auth.py, identifica vulnerabilidades de seguridad,
crea un issue en GitHub con las findings, y envía un resumen a Slack"

# Con condiciones
"Ejecuta npm test. Si algún test falla, identifica la causa raíz,
propón un fix y crea un PR con el cambio. Si todos pasan, haz merge"

# Con iteración
"Para cada archivo .py en src/workers/, añade docstrings a las
funciones públicas que no tengan. Usa Google style docstrings"

La clave del encadenamiento efectivo es ser específico en cada paso. Claude Code ejecuta los pasos secuencialmente, usando el resultado de cada paso como input del siguiente. Si un paso falla, se detiene y explica por qué.

Combinando ! con prompts:

# Primero ejecutas un comando para obtener contexto
! git diff --stat HEAD~5
# Luego pides a Claude Code que actúe sobre ese contexto
"Resume los cambios de los últimos 5 commits y genera un changelog"

Esta técnica de "contexto primero, acción después" es la forma más efectiva de trabajar con Claude Code. El comando ! te da datos reales, y el prompt convierte esos datos en acción.

10 trucos de productividad

1. Prompt directo desde terminal: claude "qué hace este archivo?" src/main.py — responde sin abrir sesión interactiva.
2. Pipe de archivos: cat error.log | claude "explica estos errores" — pasa el contenido directamente.
3. Modo headless: claude --print "genera un .gitignore para Python" — output sin interfaz, ideal para scripts.
4. Resume sesión: claude --resume — continúa la última sesión con todo el contexto.
5. Múltiples archivos: menciona rutas en tu prompt y Claude Code los lee automáticamente. No necesitas copiar/pegar.
6. Compact antes de saturar: cuando notes que las respuestas empiezan a perder contexto o a repetirse, ejecuta /compact. No esperes a que la sesión se llene por completo.
7. Modelo según tarea: usa /model haiku para tareas rápidas (formateo, preguntas simples), /model sonnet para desarrollo normal, y /model opus solo para razonamiento complejo (arquitectura, debugging difícil).
8. CLAUDE.md como contexto permanente: todo lo que Claude Code necesita saber sobre tu proyecto debe estar en CLAUDE.md. Convenciones, estructura, dependencias, decisiones de arquitectura. Así no lo repites en cada sesión.
9. Comandos custom para tareas repetitivas: si haces algo más de 3 veces, crea un comando custom. La inversión de 5 minutos creando el .md se recupera en la primera semana.
10. Git integrado: Claude Code sabe hacer git. En lugar de salir a la terminal para hacer commit, push o crear ramas, pídele que lo haga. "Haz commit de los cambios con un mensaje descriptivo y push a origin".

Para la guía completa de qué es Claude Code y cómo instalarlo, tenemos artículos dedicados. Si quieres conectar con herramientas externas, lee la guía de MCP.

Preguntas frecuentes