Objetivo

Dominar los comandos slash nativos de Claude Code para aumentar tu productividad y controlar mejor tus sesiones de trabajo.

¿Qué son los comandos slash?

Los comandos slash son atajos que empiezan con / y permiten ejecutar acciones específicas en Claude Code sin necesidad de escribir prompts largos.

Tipos de comandos slash

Nota: Anteriormente los comandos personalizados se ubicaban en .claude/commands/. Ese formato aún funciona pero el recomendado actualmente es .claude/skills/. Ambos crean comandos slash invocables con /nombre.

En este punto nos enfocaremos en los comandos nativos más útiles.

Cómo usar comandos slash

# En una sesión de Claude Code
> /comando

Tip: Escribe / y verás un menú autocompletable con todos los comandos disponibles.

Comandos esenciales del día a día

/config - Configuración general

¿Qué hace?: Abre la interfaz de configuración interactiva.

Uso:

> /config

Qué puedes configurar:

• Preferencias generales
• Vim mode (activar/desactivar)
• Notificaciones
• Permisos

Caso de uso: "Quiero ajustar mis preferencias generales de Claude Code"

Tip: Para cambiar el tema visual usa /theme, y para cambiar de modelo usa /model.

/model - Cambiar modelo

¿Qué hace?: Cambia el modelo de IA en la sesión actual.

Uso:

> /model

Atajo de teclado:

• macOS: Option + P
• Windows/Linux: Alt + P

Cuándo cambiar de modelo:

Ejemplo práctico:

# Estás en Sonnet trabajando en código
> /model
# Seleccionas Opus
> Ahora diseña la arquitectura del sistema de pagos
# Claude usa Opus para esta tarea compleja

Tip: El cambio de modelo solo afecta la sesión actual, no es permanente.

/context - Ver uso de contexto

¿Qué hace?: Muestra una visualización del uso actual de tu ventana de contexto.

Uso:

> /context

Qué muestra:

• Cuadrícula coloreada representando el contexto usado
• Porcentaje de ventana de contexto consumida
• Espacio disponible restante

Cuándo usarlo:

• Antes de iniciar una tarea grande
• Cuando notas que las respuestas son más lentas
• Cada 20-30 mensajes en conversaciones largas

Caso de uso:

# Has estado trabajando por 40 mensajes
> /context
# Ves que el contexto está al 80%
> /compact  # Decides comprimir para continuar

/compact - Comprimir conversación

¿Qué hace?: Reduce la conversación actual manteniendo la información esencial, liberando espacio de contexto.

Uso:

> /compact

Uso con instrucciones:

> /compact enfócate en los cambios de autenticación
> /compact mantén solo la implementación final

Cuándo usarlo:

• /context muestra contexto casi lleno (>70%)
• Conversación muy larga (>40 mensajes)
• Antes de cambiar de tema en la misma sesión
• Notas que Claude "olvida" cosas mencionadas antes

Ejemplo práctico:

# Llevas 50 mensajes trabajando en un feature
> /context
# Contexto al 85%
> /compact mantén solo el código final y decisiones arquitectónicas
# Claude comprime, liberas ~50% del contexto
> Ahora trabajemos en el siguiente módulo

⚠️ Importante: La compresión es irreversible. Si tienes dudas, usa /export antes.

Gestión de sesiones

/resume - Retomar conversación

¿Qué hace?: Permite retomar una conversación anterior.

Uso:

# Abrir selector interactivo
> /resume
 
# Reanudar por nombre
> /resume auth-refactor
 
# Reanudar por ID
> /resume 550e8400-e29b-41d4-a716-446655440000

Caso de uso:

# Hoy quieres continuar lo que trabajaste ayer
> /resume
# Seleccionas "refactor-payment-module" de la lista
# Continúas exactamente donde lo dejaste

Tip: Usa /rename para nombrar sesiones importantes y encontrarlas fácilmente.

/rename - Nombrar sesión

¿Qué hace?: Asigna un nombre descriptivo a la sesión actual.

Uso:

> /rename nombre-descriptivo

Ejemplos:

> /rename refactor-payment-module
> /rename bug-fix-authentication
> /rename feature-dark-mode

Mejor práctica:

• Usa nombres descriptivos en kebab-case
• Renombra al inicio de la sesión o cuando definas el objetivo
• Facilita usar /resume posteriormente

/rewind - Retroceder en la conversación

¿Qué hace?: Deshace los últimos cambios de código y mensajes, retrocediendo en la conversación.

Uso:

> /rewind

Atajo de teclado: Esc + Esc (presiona Escape dos veces)

Caso de uso:

# Claude hizo cambios que rompieron el código
> /rewind
# Vuelves al estado anterior, antes del cambio
> Hagamos esto de otra manera...

⚠️ Importante:

• Revierte tanto la conversación como los cambios en archivos
• Útil para probar diferentes enfoques

/clear - Borrar historial

¿Qué hace?: Limpia completamente la conversación actual, comenzando de cero.

Uso:

> /clear

Cuándo usarlo:

• Quieres empezar desde cero en el mismo proyecto
• Cambio total de tema
• Alternativa a iniciar nueva sesión

Diferencia con /compact:

• /clear: Borra todo, empiezas de cero
• /compact: Reduce pero mantiene contexto esencial

Información y monitoreo

/stats - Estadísticas de uso

¿Qué hace?: Muestra tus estadísticas de uso de Claude Code.

Uso:

> /stats

Qué muestra:

• Uso diario de Claude Code
• Historial de sesiones
• Rachas de uso
• Preferencias de modelos (cuál usas más)

Caso de uso: "Quiero ver cuánto he usado Claude Code este mes y qué modelo prefiero"

/cost - Ver costos y tokens

¿Qué hace?: Muestra el consumo de tokens y costos asociados de la sesión actual.

Uso:

> /cost

Qué muestra:

• Tokens de input y output de la sesión
• Costo estimado acumulado

Nota: Este comando es relevante para usuarios de API (pago por uso). Si usas un plan de suscripción (Pro/Max), consulta /usage para ver tus límites.

Caso de uso: "Esta conversación está siendo muy larga, ¿cuánto estoy consumiendo?"

/usage - Límites del plan

¿Qué hace?: Muestra tu uso actual versus los límites de tu plan de suscripción.

Uso:

> /usage

Qué muestra:

• Estado de rate limits
• Información de renovación de límites

Nota: Este comando es exclusivo para usuarios con plan de suscripción (Pro/Max). Si usas la API directamente, consulta /cost para ver tu consumo.

Caso de uso: "¿Estoy cerca de alcanzar mi límite de uso?"

/status - Estado del sistema

¿Qué hace?: Muestra información del sistema y conectividad.

Uso:

> /status

Qué muestra:

• Versión de Claude Code
• Modelo actual
• Estado de cuenta
• Conectividad a servicios

Caso de uso: "Claude Code se comporta raro, ¿hay algún problema?"

/doctor - Diagnóstico

¿Qué hace?: Verifica la salud de tu instalación de Claude Code.

Uso:

> /doctor

Qué verifica:

• Instalación correcta
• Permisos de archivos
• Configuración válida
• Dependencias

Caso de uso: "Algo no funciona bien, quiero diagnosticar el problema"

Productividad

/export - Exportar conversación

¿Qué hace?: Exporta la conversación actual a un archivo Markdown.

Uso:

# Exportar a portapapeles
> /export
 
# Exportar a archivo
> /export session-notes.md
> /export docs/architecture-decisions.md

Cuándo usarlo:

• Documentar decisiones técnicas
• Compartir conversación con el equipo
• Backup antes de /compact
• Crear ADRs (Architecture Decision Records)

Ejemplo práctico:

# Decidiste la arquitectura del sistema
> /export docs/adr/001-payment-architecture.md
# Ahora tienes documentación permanente de la decisión

/tasks - Tareas en background

¿Qué hace?: Lista y gestiona tareas ejecutándose en segundo plano.

Uso:

> /tasks

Qué muestra:

• Agentes corriendo en background
• Comandos bash largos en ejecución
• Estado de cada tarea (running/completed/failed)

Caso de uso:

# Lanzaste un refactor masivo en background
> /tasks
# Ves el progreso: "Refactoring 47/100 files"

/todos - Lista de pendientes

¿Qué hace?: Muestra la lista de TODOs que Claude está rastreando.

Uso:

> /todos

Qué muestra:

• Tareas pendientes
• Tareas completadas
• Tarea actual en progreso

Caso de uso: "Pedí a Claude implementar un feature, ¿qué le falta?"

Ejemplo:

> /todos
✓ Implementar login endpoint
✓ Agregar validación de JWT
⏳ Escribir tests unitarios (en progreso)
☐ Documentar API
☐ Configurar rate limiting

Integración y extensibilidad

/mcp - Gestionar servidores MCP

¿Qué hace?: Abre la interfaz para gestionar conexiones de Model Context Protocol.

Uso:

> /mcp

Qué puedes hacer:

• Ver servidores MCP conectados
• Habilitar/deshabilitar servidores
• Configurar autenticación OAuth
• Conectar nuevos servidores

Ejemplo práctico:

> /mcp
# Seleccionas "Enable GitHub MCP"
# Autorizas OAuth
# Ahora Claude puede gestionar tus repos, issues y PRs directamente

Servidores MCP populares:

• GitHub: Gestión de repos, issues, PRs
• PostgreSQL: Consultas a base de datos
• Slack: Enviar mensajes, leer canales
• Playwright: Testing de navegadores

Nota: Profundizaremos en MCP en el Módulo 6.

/statusline - Personalizar línea de estado

¿Qué hace?: Configura qué información se muestra en la barra de estado inferior.

Uso:

> /statusline

Qué puedes mostrar:

• Rama de git actual
• Uso de contexto
• Modelo actual
• Información custom con scripts

Caso de uso: "Quiero ver siempre la rama de git y el uso de contexto sin ejecutar comandos"

Tip: Es un comando interactivo que te guía paso a paso para configurar qué información mostrar en la barra de estado.

/terminal-setup - Configurar terminal

¿Qué hace?: Ayuda a configurar atajos de teclado específicos del terminal.

Uso:

> /terminal-setup

Qué configura:

• Shift + Enter: Input multilínea
• Option/Alt + T: Toggle extended thinking
• Otros atajos según tu terminal

Cuándo usarlo:

• Primera vez usando Claude Code
• Cambias de terminal (ej: de iTerm a VS Code terminal)
• Shift + Enter no funciona para multilínea

Nota: En terminales como iTerm2, WezTerm, Ghostty y Kitty, Shift + Enter ya funciona nativamente y este comando no aparecerá. Este comando solo se muestra cuando Claude Code detecta que tu terminal necesita configuración adicional.

Memoria y contexto del proyecto

/memory - Editar CLAUDE.md

¿Qué hace?: Abre el archivo CLAUDE.md del proyecto para editarlo.

Uso:

> /memory

Qué hace internamente:

• Busca CLAUDE.md en el directorio actual
• Si no existe, te pregunta si quieres crearlo
• Abre el archivo para que lo edites

Caso de uso:

# Cambió la convención de nombres en tu equipo
> /memory
# Editas CLAUDE.md para actualizar las reglas
# Claude ahora respeta la nueva convención

Equivalente a: Editar .claude/CLAUDE.md manualmente

/init - Inicializar proyecto

¿Qué hace?: Crea un archivo CLAUDE.md inicial para el proyecto.

Uso:

> /init

Qué genera:

• Plantilla básica de CLAUDE.md
• Secciones sugeridas (arquitectura, convenciones, etc.)
• Placeholder para que lo completes

Caso de uso:

# Proyecto nuevo sin CLAUDE.md
> /init
# Claude crea el archivo con estructura básica
# Lo completas con info de tu proyecto

Tip: Siempre inicializa CLAUDE.md en proyectos nuevos. Ahorra muchos tokens y mejora la calidad de las respuestas.

Comandos adicionales

Claude Code incluye otros comandos nativos para casos específicos:

Tip: Escribe / y explora la lista completa. Nuevos comandos pueden añadirse en actualizaciones.

Atajos de teclado útiles

Flujo de trabajo recomendado

Al iniciar sesión

> /resume           # Retomar si continúas algo
> /rename feature-x # Nombrar la sesión actual
> /model            # Confirmar modelo adecuado

Durante el trabajo

> /context          # Cada ~20 mensajes
> /compact          # Si contexto >70%
> /todos            # Ver progreso

Al finalizar

> /export session-notes.md  # Documentar si fue importante
> /stats                    # Ver estadísticas (opcional)

Tips generales

1. Usa autocompletado: Escribe / y navega con flechas
2. Combina comandos: Puedes usar varios comandos en secuencia
3. Monitorea contexto: /context regularmente evita quedarte sin espacio
4. Nombra sesiones: /rename facilita retomar trabajo
5. Exporta decisiones: /export para documentación permanente
6. Experimenta: Los comandos son seguros, no temas probarlos

Diferencia: Comandos slash vs. Prompts normales

Regla general: Si es una acción del sistema (cambiar config, ver estado), usa comando slash. Si es trabajo de código, usa prompt.

Ejercicio práctico

Ejecuta los siguientes comandos en orden y observa qué hacen:

# 1. Ver estado actual
> /context
> /stats
 
# 2. Experimentar con configuración
> /config
# Cambia el tema visual
 
# 3. Gestión de sesión
> /rename practica-comandos-slash
> /export practica-comandos.md
 
# 4. Información
> /usage
> /cost
 
# 5. Probar compresión (si tienes conversación larga)
> /context
> /compact
> /context
# Observa la diferencia

Desafío adicional:

• Usa Option+P / Alt+P para cambiar de modelo
• Prueba Esc + Esc para retroceder un mensaje
• Escribe / y explora comandos que no cubrimos

Resumen

Los comandos slash nativos son herramientas poderosas que:

✅ Aumentan tu productividad ✅ Te dan control sobre el sistema ✅ Facilitan la gestión de sesiones ✅ Optimizan el uso de contexto ✅ Mejoran la experiencia de desarrollo

Comandos imprescindibles para memorizar:

• /model - Cambiar modelo
• /context - Ver contexto
• /compact - Comprimir conversación
• /resume - Retomar sesión
• /export - Exportar conversación

Próximo paso

En el siguiente punto (4.2) aprenderás a crear tus propios comandos slash personalizados, adaptados a tu flujo de trabajo específico.

Recursos:

• Documentación oficial de Claude Code
• Referencia de CLI

4.2 Crear comandos personalizados (Skills)

Objetivo

Aprender a crear skills personalizadas que extiendan Claude Code con comandos adaptados a tu flujo de trabajo específico.

¿Qué son las skills?

Las skills son comandos slash personalizados que tú defines para automatizar tareas repetitivas o estandarizar flujos de trabajo. Cuando creas una skill, aparece en el menú de autocompletado al escribir / y Claude sigue las instrucciones que le hayas definido.

¿Por qué crear skills?

Ubicación de las skills

Las skills pueden vivir en dos niveles:

~/.claude/skills/nombre/SKILL.md    → Skills globales (todos tus proyectos)
.claude/skills/nombre/SKILL.md      → Skills del proyecto (compartidas vía git)

Prioridad

Cuando una skill tiene el mismo nombre en varios niveles, la prioridad es:

1. Personal (~/.claude/skills/) — Tu configuración prevalece
2. Proyecto (.claude/skills/) — Compartida con el equipo

Nota: El formato legacy .claude/commands/nombre.md sigue funcionando, pero .claude/skills/ es el formato recomendado porque soporta archivos de soporte, control de invocación y ejecución en subagentes.

Estructura de archivos

Cada skill es un directorio con un archivo SKILL.md como punto de entrada:

.claude/skills/
├── commit/
│   └── SKILL.md              → Skill para commits
├── test/
│   └── SKILL.md              → Skill para generar tests
└── review/
    ├── SKILL.md              → Skill para code review
    ├── checklist.md          → Archivo de apoyo con checklist
    └── examples/
        └── good-review.md    → Ejemplo de review bien hecho

Regla: El nombre del directorio se convierte en el nombre del comando slash. El directorio commit/ genera el comando /commit.

Anatomía de una skill

Un archivo SKILL.md tiene dos partes: el frontmatter (configuración YAML) y el cuerpo (instrucciones para Claude).

Estructura básica

---
description: Descripción de qué hace la skill
argument-hint: [argumento-opcional]
---
 
Instrucciones que Claude seguirá cuando se invoque esta skill.

Frontmatter: configuración YAML

El frontmatter es un bloque YAML delimitado por --- al inicio del archivo. Define el comportamiento de la skill.

Campos disponibles

Ejemplo completo de frontmatter

---
description: Genera un mensaje de commit siguiendo Conventional Commits
argument-hint: [tipo-de-cambio]
disable-model-invocation: true
allowed-tools: Bash(git:*)
---

Detalle de cada campo

description

Claude usa la descripción para decidir si debe invocar la skill automáticamente. Una buena descripción incluye qué hace y cuándo usarla:

# Buena descripción
description: Genera tests unitarios completos. Usar cuando se crea código nuevo sin tests o cuando se pide mejorar la cobertura.
 
# Descripción pobre
description: Tests

argument-hint

Se muestra como placeholder cuando el usuario escribe /nombre:

argument-hint: [ruta-del-archivo]
# El usuario ve: /review [ruta-del-archivo]

disable-model-invocation

Controla si Claude puede invocar la skill por su cuenta:

# Solo tú la invocas manualmente con /deploy
disable-model-invocation: true

Usa esto para skills con efectos secundarios (deploy, enviar mensajes, commits).

allowed-tools

Herramientas que Claude puede usar sin pedir confirmación cuando la skill está activa:

allowed-tools: Read, Grep, Bash(npm test:*)

context: fork

Ejecuta la skill en un subagente aislado con su propio contexto:

context: fork
agent: Explore

Útil para skills de investigación que no necesitan modificar la conversación principal.

Cuerpo: las instrucciones

El cuerpo del SKILL.md (después del frontmatter) es el prompt que Claude recibe cuando se invoca la skill. Aquí defines exactamente qué debe hacer.

Ejemplo simple

---
description: Genera un resumen del estado actual del proyecto
---
 
Analiza el estado actual del proyecto:
 
1. Lee el archivo README.md
2. Revisa los últimos 5 commits con `git log --oneline -5`
3. Identifica archivos modificados recientemente
4. Genera un resumen breve del estado del proyecto
 
Formato del resumen:
- Estado general (una línea)
- Cambios recientes (bullet points)
- Próximos pasos sugeridos

Variables y contexto dinámico

$ARGUMENTS — Recibir parámetros del usuario

Cuando el usuario escribe /skill argumento1 argumento2, todo lo que va después del nombre se captura en $ARGUMENTS:

---
description: Explica un archivo del proyecto
argument-hint: [ruta-del-archivo]
---
 
Explica el archivo $ARGUMENTS de forma clara y concisa:
 
1. Propósito del archivo
2. Funciones/clases principales
3. Dependencias importantes
4. Cómo se integra con el resto del proyecto

Invocación:

> /explain src/services/auth.ts
# $ARGUMENTS = "src/services/auth.ts"

Tip: Si $ARGUMENTS no aparece en el cuerpo, los argumentos se añaden automáticamente al final del prompt.

${CLAUDE_SESSION_ID} — ID de sesión

Variable disponible para logging o correlación:

Log de la sesión ${CLAUDE_SESSION_ID}: ...

Ejecución de shell con !

Puedes ejecutar comandos de shell antes de que Claude reciba el prompt usando la sintaxis !`comando`. La salida del comando reemplaza el placeholder:

---
description: Resume el estado del PR actual
---
 
## Contexto del PR
 
Diff actual:
!`git diff main...HEAD`
 
Archivos modificados:
!`git diff --name-only main...HEAD`
 
## Tu tarea
 
Resume los cambios del PR actual:
1. Qué se cambió y por qué
2. Archivos afectados (agrupados por tipo)
3. Riesgos potenciales

Flujo de ejecución:

1. Claude Code ejecuta cada !`comando` inmediatamente
2. La salida reemplaza el placeholder en el texto
3. Claude recibe el prompt ya con los datos reales

Importante: Los comandos se ejecutan en el directorio de trabajo actual del proyecto.

Control de invocación

Las skills pueden ser invocadas de dos formas: por el usuario o automáticamente por Claude.

Tipos de invocación

¿Cuándo Claude invoca automáticamente una skill?

Claude invoca una skill cuando:

• La conversación coincide naturalmente con la descripción de la skill
• La skill no tiene disable-model-invocation: true
• La skill es relevante para la tarea actual

Ejemplo: Si tienes una skill con description: "Genera tests unitarios" y le dices a Claude "este código no tiene tests", Claude puede invocar la skill automáticamente.

Archivos de soporte

Puedes incluir archivos adicionales en el directorio de la skill. Claude los descubre y puede usarlos como referencia:

.claude/skills/review/
├── SKILL.md            → Instrucciones principales
├── checklist.md        → Checklist de revisión
├── severity-guide.md   → Guía de severidades
└── examples/
    └── sample.md       → Ejemplo de output esperado

En el SKILL.md, referencia los archivos para que Claude sepa que existen:

## Recursos adicionales
 
- Para la checklist completa, consulta checklist.md
- Para ejemplos de reviews, ver examples/sample.md

Ejemplos prácticos

Skill: /commit — Mensajes de commit estandarizados

---
description: Crea un mensaje de commit siguiendo Conventional Commits
disable-model-invocation: true
argument-hint: [tipo]
allowed-tools: Bash(git:*)
---
 
Genera un mensaje de commit para los cambios staged.
 
Contexto actual:
!`git diff --cached`
 
## Reglas
 
1. Usa el formato Conventional Commits: `tipo(scope): descripción`
2. Tipos válidos: feat, fix, refactor, docs, test, chore, perf, style
3. Si el usuario especificó tipo, usa: $ARGUMENTS
4. La descripción debe:
   - Empezar en minúscula
   - Usar modo imperativo
   - Máximo 72 caracteres en la primera línea
5. Incluye body si los cambios son complejos
6. Ejecuta el commit con `git commit -m "mensaje"`

Uso:

> git add src/auth.ts
> /commit fix
# Claude genera: fix(auth): corregir validación de token expirado

Skill: /test — Generación de tests

---
description: Genera tests unitarios completos para un archivo. Usar cuando se necesitan tests nuevos o mejorar cobertura existente.
argument-hint: [archivo]
allowed-tools: Read, Write, Bash(npm test:*)
---
 
Genera tests unitarios para $ARGUMENTS.
 
## Proceso
 
1. Lee el archivo fuente y entiende su funcionalidad
2. Identifica las funciones/métodos exportados
3. Genera tests cubriendo:
   - Caso feliz (happy path)
   - Casos límite (edge cases)
   - Manejo de errores
   - Valores nulos/undefined
 
## Convenciones
 
- Framework: usa el que ya esté configurado en el proyecto (Jest, Vitest, etc.)
- Naming: `describe("NombreFuncion", () => { it("should...", ...) })`
- Ubicación: mismo directorio con sufijo `.test.ts` o `.spec.ts`
- Ejecuta los tests al final para verificar que pasan

Uso:

> /test src/utils/validator.ts
# Claude genera validator.test.ts con tests completos

Skill: /doc — Documentación de funciones

---
description: Documenta funciones y clases con JSDoc/TSDoc
argument-hint: [archivo]
allowed-tools: Read, Write
---
 
Añade documentación JSDoc/TSDoc a las funciones y clases de $ARGUMENTS.
 
## Reglas
 
1. Solo documenta funciones/clases exportadas
2. Incluye:
   - Descripción breve
   - @param con tipo y descripción
   - @returns con tipo y descripción
   - @throws si aplica
   - @example con un ejemplo de uso
3. No modifiques la lógica del código, solo añade comentarios
4. Usa español para las descripciones

Skill: /pr-summary — Resumen de PR con contexto dinámico

---
description: Resume los cambios del PR actual
disable-model-invocation: true
context: fork
agent: Explore
allowed-tools: Bash(gh:*)
---
 
## Contexto del PR
 
Diff:
!`gh pr diff`
 
Comentarios:
!`gh pr view --comments`
 
Archivos modificados:
!`gh pr diff --name-only`
 
## Tarea
 
Resume este Pull Request:
1. Qué cambió y por qué (2-3 bullets)
2. Archivos afectados agrupados por área
3. Decisiones técnicas relevantes
4. Riesgos o concerns potenciales
5. Sugerencias de testing

Skill: /stack-check — Verificación rápida del proyecto

---
description: Verifica el estado de salud del proyecto (build, tests, lint)
disable-model-invocation: true
allowed-tools: Bash(npm:*, npx:*)
---
 
Ejecuta las verificaciones de salud del proyecto:
 
1. **Build**: Ejecuta el build y reporta errores
2. **Tests**: Ejecuta la suite de tests
3. **Lint**: Ejecuta el linter
 
Para cada paso, reporta:
- Estado (pass/fail)
- Número de errores/warnings si hay
- Resumen de los problemas encontrados
 
Si todo pasa, confirma con un resumen breve.
Si hay fallos, prioriza por severidad.

Compartir skills con el equipo

Skills de proyecto (vía git)

Las skills en .claude/skills/ se comparten automáticamente al hacer commit:

# Crear skill de proyecto
mkdir -p .claude/skills/commit
# Escribir SKILL.md...
 
# Compartir con el equipo
git add .claude/skills/
git commit -m "feat: añadir skill de commit estandarizado"
git push

Cuando un compañero hace git pull, la skill estará disponible automáticamente.

Skills personales (solo para ti)

Las skills en ~/.claude/skills/ son privadas y aplican a todos tus proyectos:

mkdir -p ~/.claude/skills/mi-skill-personal
# Escribir SKILL.md...
# No se comparte, solo existe en tu máquina

Buenas prácticas

1. Nombres descriptivos

# Bien
.claude/skills/commit-conventional/
.claude/skills/review-security/
.claude/skills/generate-api-tests/
 
# Mal
.claude/skills/c/
.claude/skills/misc/
.claude/skills/stuff/

2. Descriptions claras

La descripción es lo que Claude usa para decidir si invocar la skill. Sé específico:

# Bien
description: Genera tests de integración para endpoints REST. Usar cuando se crean nuevos endpoints o se modifican existentes.
 
# Mal
description: Hace tests

3. Usa disable-model-invocation: true para acciones destructivas

Cualquier skill que haga commit, deploy, envíe mensajes o tenga efectos secundarios debería ser solo manual:

disable-model-invocation: true

4. Mantén las skills enfocadas

Cada skill debe hacer una cosa bien. Si necesitas un flujo complejo, crea varias skills:

.claude/skills/test-unit/         → Tests unitarios
.claude/skills/test-integration/  → Tests de integración
.claude/skills/test-e2e/          → Tests end-to-end

5. Usa archivos de soporte para contenido extenso

Si tu skill necesita templates, ejemplos o documentación larga, muévelos a archivos separados:

.claude/skills/review/
├── SKILL.md          → Instrucciones concisas (~50 líneas)
├── checklist.md      → Checklist detallada
└── examples.md       → Ejemplos de output

6. Incluye el formato de output esperado

Dile a Claude exactamente cómo quieres la respuesta:

## Formato de salida
 

tipo(scope): descripción breve

• Detalle 1
• Detalle 2

Formato legacy: .claude/commands/

El formato anterior usaba archivos directos en .claude/commands/:

.claude/commands/commit.md    → Generaba /commit
.claude/commands/test.md      → Generaba /test

Este formato sigue funcionando pero tiene limitaciones:

• No soporta archivos de soporte (solo un archivo por comando)
• No soporta context: fork ni ejecución en subagentes
• No soporta el campo user-invocable

Si tienes commands legacy, migrar es sencillo:

# De legacy
.claude/commands/commit.md
 
# A skills (recomendado)
.claude/skills/commit/SKILL.md
# (mismo contenido, simplemente moverlo)

Ejercicio práctico

Parte 1: Crear tu primera skill

Crea una skill /hello que salude y muestre info del proyecto:

mkdir -p .claude/skills/hello

Escribe el SKILL.md:

---
description: Muestra un saludo con información básica del proyecto
disable-model-invocation: true
---
 
Saluda al usuario y muestra:
 
1. Nombre del proyecto (del package.json o README)
2. Rama actual de git
3. Últimos 3 commits
4. Estado de archivos modificados
 
Formato amigable y conciso.

Pruébala:

> /hello

Parte 2: Crear skill /commit

Crea una skill que genere commits con Conventional Commits. Incluye:

• Frontmatter con disable-model-invocation: true
• Uso de !`git diff --cached` para contexto dinámico
• Formato de Conventional Commits
• Variable $ARGUMENTS para el tipo de commit

Parte 3: Crear skill con archivos de soporte

Crea una skill /review que incluya:

• SKILL.md con las instrucciones principales
• checklist.md con una checklist de revisión de código
• Referencia al archivo de soporte desde SKILL.md

Desafío adicional

• Crea una skill personal (en ~/.claude/skills/) que sea útil para todos tus proyectos
• Crea una skill que use context: fork para investigar el codebase sin afectar la conversación
• Experimenta con user-invocable: false para crear una skill que Claude use automáticamente cuando detecte código sin documentar

Resumen

Próximo paso

En el siguiente módulo (5) aprenderás sobre Hooks, que permiten ejecutar acciones automáticas cuando Claude usa herramientas como Write o Bash.

Recursos:

• Documentación oficial de Skills
• Referencia de CLI

Práctica del módulo 4: Comandos slash y skills

En esta práctica explorarás los comandos slash nativos de Claude Code y crearás tus primeras skills personalizadas adaptadas a tu flujo de trabajo.

Objetivos

• Explorar los comandos slash nativos más importantes
• Crear skill /commit para mensajes de commit estandarizados
• Crear skill /test para generar tests unitarios
• Crear skill específica para tu stack tecnológico

Ejercicio 1: Explorar comandos slash nativos

Paso 1.1: Preparar el entorno

Abre un proyecto existente (o crea uno de prueba) e inicia Claude Code:

cd ~/tu-proyecto
claude

Paso 1.2: Comandos de información

Ejecuta los siguientes comandos y observa su salida:

> /context

Anota: ¿Cuánto contexto tienes disponible?

> /cost

Anota: ¿Cuántos tokens has consumido hasta ahora?

> /status

Anota: ¿Qué modelo estás usando? ¿Qué versión de Claude Code tienes?

Paso 1.3: Gestión de sesión

Nombra tu sesión actual para poder retomarla después:

> /rename practica-modulo-4

Paso 1.4: Cambiar modelo

Prueba a cambiar de modelo durante la sesión:

> /model

Selecciona un modelo diferente (por ejemplo, Haiku para tareas rápidas). Pide algo sencillo y observa la diferencia en velocidad de respuesta. Después vuelve a tu modelo habitual.

Paso 1.5: Compresión de contexto

Escribe varios mensajes (al menos 5-10) para generar algo de historial. Después:

> /context

Anota el porcentaje de uso.

> /compact mantén solo los comandos probados en esta práctica

> /context

Compara: ¿Cuánto contexto se liberó?

Paso 1.6: Atajos de teclado

Prueba los siguientes atajos:

Verificación: Has usado al menos 5 comandos slash nativos y entiendes para qué sirve cada uno.

Ejercicio 2: Crear skill /commit

Paso 2.1: Crear la estructura

mkdir -p .claude/skills/commit

Paso 2.2: Escribir el SKILL.md

Crea el archivo .claude/skills/commit/SKILL.md con el siguiente contenido:

---
description: Genera un mensaje de commit siguiendo Conventional Commits
disable-model-invocation: true
argument-hint: [tipo]
allowed-tools: Bash(git:*)
---
 
Genera un mensaje de commit para los cambios actualmente en staging.
 
## Contexto
 
Cambios staged:
!`git diff --cached`
 
Estado del repositorio:
!`git status --short`
 
## Reglas
 
1. Formato Conventional Commits: `tipo(scope): descripción`
2. Tipos válidos: feat, fix, refactor, docs, test, chore, perf, style
3. Si el usuario proporcionó tipo, usar: $ARGUMENTS
4. Si no hay tipo, inferirlo de los cambios
5. La descripción debe:
   - Empezar en minúscula
   - Usar modo imperativo ("añadir", no "añadido")
   - Máximo 72 caracteres en el header
6. Incluir body explicando el "por qué" si los cambios son complejos
7. Ejecutar el commit con `git commit -m "mensaje"`
 
## Ejemplo de output
 
feat(auth): añadir validación de token JWT
 
Se añade middleware de validación para tokens expirados.
Esto previene accesos no autorizados a rutas protegidas.

Paso 2.3: Probar la skill

Haz un cambio en algún archivo del proyecto:

echo "// cambio de prueba" >> src/app.ts
git add src/app.ts

Inicia Claude Code y prueba:

> /commit fix

Claude debería generar un mensaje de commit basado en el diff y ejecutar el commit.

Paso 2.4: Probar sin argumentos

Haz otro cambio y prueba sin especificar tipo:

echo "// otro cambio" >> src/app.ts
git add src/app.ts

> /commit

Claude debería inferir el tipo de commit a partir del contenido del cambio.

Verificación: La skill genera commits formateados correctamente y el historial de git muestra los mensajes con formato Conventional Commits.

Ejercicio 3: Crear skill /test

Paso 3.1: Crear la estructura

mkdir -p .claude/skills/test

Paso 3.2: Escribir el SKILL.md

Crea el archivo .claude/skills/test/SKILL.md:

---
description: Genera tests unitarios completos para un archivo. Usar cuando se necesitan tests nuevos o cuando se pide mejorar cobertura.
argument-hint: [archivo]
allowed-tools: Read, Write, Bash(npm test:*, npx vitest:*, npx jest:*)
---
 
Genera tests unitarios para el archivo: $ARGUMENTS
 
## Proceso
 
1. Lee el archivo fuente y comprende su funcionalidad
2. Identifica el framework de testing del proyecto (package.json)
3. Identifica funciones/métodos/clases exportados
4. Genera tests cubriendo:
   - Caso feliz (happy path)
   - Casos límite (edge cases)
   - Manejo de errores
   - Valores nulos o undefined (si aplica)
 
## Convenciones
 
- Ubicación: mismo directorio con sufijo `.test.ts` o `.spec.ts`
- Naming: `describe("NombreFuncion/Clase", () => { it("should...", ...) })`
- Cada test debe ser independiente y no depender de otros
- Mockear dependencias externas (APIs, DB, filesystem)
- Al finalizar, ejecutar los tests para verificar que pasan
 
## Estructura esperada
 
```typescript
import { funcionATestear } from './archivo';
 
describe('funcionATestear', () => {
  it('should [comportamiento esperado] when [condición]', () => {
    // Arrange
    // Act
    // Assert
  });
});

 
### Paso 3.3: Crear un archivo para testear
 
Crea un archivo de ejemplo en tu proyecto:
 
```typescript
// src/utils/calculator.ts
export function add(a: number, b: number): number {
  return a + b;
}
 
export function divide(a: number, b: number): number {
  if (b === 0) throw new Error("Division by zero");
  return a / b;
}
 
export function isEven(n: number): boolean {
  return n % 2 === 0;
}

Paso 3.4: Probar la skill

> /test src/utils/calculator.ts

Claude debería:

1. Leer el archivo
2. Detectar el framework de tests del proyecto
3. Generar calculator.test.ts con tests completos
4. Ejecutar los tests

Paso 3.5: Verificar la cobertura

Revisa el archivo generado:

• ¿Cubre add con números positivos, negativos y cero?
• ¿Cubre divide con división normal y por cero?
• ¿Cubre isEven con pares, impares y casos límite?

Verificación: Los tests generados pasan y cubren los principales escenarios de cada función.

Ejercicio 4: Crear skill para tu stack

Paso 4.1: Identificar una tarea repetitiva

Piensa en algo que haces frecuentemente en tu proyecto. Algunos ejemplos:

Paso 4.2: Planificar la skill

Antes de escribir, responde:

1. Nombre: ¿Cómo la invocarás? (/nombre)
2. Descripción: ¿Qué hace exactamente?
3. Argumentos: ¿Necesita parámetros del usuario?
4. Invocación: ¿Solo manual o también automática?
5. Herramientas: ¿Qué tools necesita? (Read, Write, Bash)
6. Contexto dinámico: ¿Necesita ejecutar comandos antes? (!`cmd`)
7. Output: ¿Qué formato de salida esperas?

Paso 4.3: Crear la skill

mkdir -p .claude/skills/tu-skill

Escribe el SKILL.md siguiendo la estructura aprendida:

---
description: [Tu descripción]
argument-hint: [tus argumentos]
disable-model-invocation: [true/false]
allowed-tools: [herramientas necesarias]
---
 
[Tus instrucciones para Claude]

Paso 4.4: Probar y iterar

1. Invoca la skill con /tu-skill
2. Evalúa el resultado: ¿Es lo que esperabas?
3. Si no, ajusta las instrucciones del SKILL.md
4. Repite hasta que el output sea consistente y útil

Tip: Las instrucciones más específicas dan mejores resultados. Si Claude no genera lo que esperas, añade más detalle al formato de salida o incluye un ejemplo concreto.

Verificación: Tienes una skill funcional y útil adaptada a tu stack.

Ejercicio 5: Skills avanzadas (opcional)

Paso 5.1: Skill con archivos de soporte

Crea una skill de code review que use un archivo de checklist externo:

mkdir -p .claude/skills/review

Archivo .claude/skills/review/checklist.md:

## Checklist de revisión
 
### Seguridad
- [ ] Sin inyección SQL/XSS
- [ ] Inputs validados y sanitizados
- [ ] Sin secretos hardcodeados
 
### Rendimiento
- [ ] Sin queries N+1
- [ ] Sin loops innecesarios sobre datos grandes
- [ ] Recursos liberados correctamente
 
### Legibilidad
- [ ] Nombres descriptivos
- [ ] Funciones de menos de 30 líneas
- [ ] Sin código duplicado

Archivo .claude/skills/review/SKILL.md:

---
description: Realiza code review siguiendo la checklist del equipo
argument-hint: [archivo-o-directorio]
allowed-tools: Read, Grep
---
 
Revisa el código de $ARGUMENTS siguiendo nuestra checklist de equipo.
 
Para la checklist completa de criterios, consulta checklist.md.
 
## Proceso
 
1. Lee el código indicado
2. Evalúa cada punto de la checklist
3. Reporta los hallazgos clasificados por severidad:
   - **Crítico**: Bugs o vulnerabilidades que deben corregirse
   - **Medio**: Mejoras recomendadas
   - **Bajo**: Sugerencias de estilo
 
## Formato de salida
 
### Resumen
[1-2 líneas sobre el estado general del código]
 
### Hallazgos
- [Severidad] Descripción del problema (archivo:línea)
 
### Veredicto
Aprobado / Cambios requeridos / Bloqueado

Prueba: /review src/utils/calculator.ts

Paso 5.2: Skill con ejecución en subagente

Crea una skill de investigación que se ejecute en un contexto aislado:

mkdir -p .claude/skills/investigate

---
description: Investiga cómo funciona una feature en el codebase actual
argument-hint: [tema-a-investigar]
context: fork
agent: Explore
---
 
Investiga en profundidad: $ARGUMENTS
 
## Proceso
 
1. Busca archivos relevantes usando patrones de nombre
2. Lee los archivos clave identificados
3. Rastrea el flujo de datos y dependencias
4. Identifica patrones y convenciones usadas
 
## Formato de respuesta
 
### Archivos relevantes
- [ruta]: [qué hace]
 
### Flujo principal
[Descripción paso a paso]
 
### Dependencias
[Librerías y módulos involucrados]
 
### Observaciones
[Patrones, posibles mejoras o inconsistencias]

Prueba: /investigate autenticación o /investigate manejo de errores

Verificación: Entiendes cómo usar archivos de soporte y la ejecución en subagentes.

Checklist de validación

Marca cada punto cuando lo hayas completado:

• He explorado al menos 5 comandos slash nativos
• He probado /context y /compact para gestionar el contexto
• He cambiado de modelo con /model durante una sesión
• He creado la skill /commit y funciona correctamente
• He creado la skill /test y genera tests que pasan
• He creado una skill personalizada para mi stack
• He probado la variable $ARGUMENTS en al menos una skill
• He probado la ejecución de shell con !`comando` en al menos una skill

Troubleshooting común

La skill no aparece al escribir /

• Verifica que el archivo se llama exactamente SKILL.md (mayúsculas)
• Verifica que está dentro de .claude/skills/nombre/SKILL.md
• Reinicia la sesión de Claude Code (sal y vuelve a entrar)

Claude no sigue las instrucciones de la skill

• Sé más específico en las instrucciones
• Añade un ejemplo concreto del output esperado
• Verifica que las instrucciones no son ambiguas o contradictorias

Los comandos ! no se ejecutan

• Verifica que la sintaxis es exactamente !`comando` (backtick con exclamación)
• El comando debe ser ejecutable en tu terminal actual
• Comprueba que estás en el directorio correcto del proyecto

$ARGUMENTS no se reemplaza

• Verifica que escribiste $ARGUMENTS (con mayúsculas y sin llaves)
• Comprueba que invocaste la skill con argumentos: /skill argumento
• Si no pasas argumentos, $ARGUMENTS estará vacío

La skill hace cosas que no debería

• Añade disable-model-invocation: true si no quieres que Claude la invoque sola
• Revisa el campo allowed-tools: solo lista las herramientas necesarias
• Sé explícito sobre lo que no debe hacer en las instrucciones

Reto adicional (opcional)

Crea un kit de skills para tu equipo que incluya al menos 3 skills complementarias. Por ejemplo, un flujo de desarrollo completo:

1. /plan — Planifica una feature antes de implementar
2. /implement — Implementa según un plan dado
3. /review — Revisa el código implementado
4. /commit — Genera commit con el formato del equipo

Compártelas con tu equipo vía git:

git add .claude/skills/
git commit -m "feat(skills): añadir kit de skills del equipo"
git push

Documenta brevemente cada skill en un README dentro de .claude/skills/README.md para que tus compañeros sepan qué skills tienen disponibles.

Siguiente módulo: Hooks — Automatización post-acción