Claude Code incluye un asistente de AI de propósito general. Las Skills te permiten especializarlo. Una skill es un archivo markdown que enseña a Claude Code cómo manejar un tipo específico de tarea: desplegar en Kubernetes, escribir migraciones de base de datos, revisar pull requests o seguir las convenciones de código de tu equipo.
La diferencia entre "escríbeme un componente de React" y "escríbeme un componente de React siguiendo nuestro sistema de diseño, usando nuestros hooks personalizados, con límites de error adecuados y atributos de accesibilidad" es una skill.
Los documentos oficiales de Claude Code ahora dejan algo claro: los comandos personalizados se han fusionado en las skills. Los archivos existentes en .claude/commands/ siguen funcionando, pero las skills son la abstracción recomendada porque admiten metadatos más ricos, archivos de soporte y carga automática. Si estás estandarizando un flujo de trabajo de equipo hoy, constrúyelo primero como una skill y trata los comandos heredados como una vía de compatibilidad.
Qué son realmente las Skills
Una skill reside en un directorio con un punto de entrada SKILL.md. Claude puede cargarla automáticamente cuando la descripción coincide con la tarea actual, o puedes invocarla directamente con /nombre-de-la-skill.
.claude/
skills/
deploy/
SKILL.md # /deploy
review-pr/
SKILL.md # /review-pr
write-test/
SKILL.md # /write-test
Claude sigue admitiendo .claude/commands/deploy.md, y el slash command seguirá funcionando. Pero la versión moderna es .claude/skills/deploy/SKILL.md.
Esto parece un pequeño cambio de nombre, pero importa porque las skills pueden contener archivos de soporte, frontmatter, controles de invocación y sugerencias para subagentes. Un archivo de comando simple puede decirle a Claude qué hacer. Una skill puede decirle a Claude cómo espera tu equipo que se haga el trabajo.
Escribiendo tu primera Skill
Aquí tienes un ejemplo práctico: una skill que hace cumplir las convenciones de mensajes de commit de tu equipo.
Crea .claude/skills/commit/SKILL.md:
---
name: commit
description: Generate and validate conventional commits for this repo.
---
# Commit Workflow
## Steps
1. Run `git diff --staged` to see what's being committed
2. Analyze the changes and categorize: feat, fix, refactor, docs, test, chore
3. Write a commit message following our convention:
- Format: `type(scope): description`
- Scope is the package or module name
- Description is imperative mood, lowercase, no period
- Body explains WHY, not WHAT
4. If changes touch multiple scopes, create separate commits
5. Run `git commit -m "message"` with the generated message
## Rules
- Never use `--no-verify` to skip hooks
- Never amend published commits
- If tests fail in pre-commit, fix the issue first
## Examples
- `feat(billing): add stripe webhook handler`
- `fix(auth): handle expired refresh tokens`
- `refactor(api): extract rate limiter to shared package`
Ahora /commit le da a Claude Code un flujo de trabajo estructurado en lugar de una instrucción vaga de "haz commit de mis cambios".
Si ya tienes archivos de comandos heredados, mantenlos funcionando mientras migras, pero no sigas invirtiendo en el diseño antiguo. La documentación oficial es clara: las skills son el camino a seguir.
Dónde viven las Skills ahora
Claude Code descubre actualmente las skills desde cuatro lugares:
- skills personales:
~/.claude/skills/<nombre-de-la-skill>/SKILL.md - skills del proyecto:
.claude/skills/<nombre-de-la-skill>/SKILL.md - skills de proyecto anidadas en monorepos
- skills proporcionadas por plugins
Esto te da una división clara:
- skills personales para tu propio estilo de trabajo
- skills de proyecto para las convenciones del repositorio
- skills de plugin para flujos de trabajo empaquetados reutilizables
Para la adopción en equipo, haz commit de las skills del proyecto en el repositorio. Esa es la diferencia entre “tengo un buen prompt en mi laptop” y “el equipo ahora tiene un flujo de trabajo repetible”.
Patrones de diseño de Skills
El Patrón de Lista de Verificación
Ideal para tareas con múltiples pasos de verificación.
# Pre-Deploy Checklist
Before deploying, verify each item:
- [ ] `pnpm typecheck` passes
- [ ] `pnpm test` passes
- [ ] No console.log statements in production code
- [ ] Environment variables documented in .env.example
- [ ] Database migrations are reversible
- [ ] API changes are backward compatible
If any check fails, stop and report the issue. Do not proceed with deployment.
El Patrón de Árbol de Decisión
Ideal para tareas donde el enfoque depende del contexto.
# Bug Fix Workflow
1. Reproduce the bug (find or write a failing test)
2. Identify the root cause:
- If it's a type error → fix the type definition at the source
- If it's a race condition → add proper locking/sequencing
- If it's a missing validation → add schema validation at the boundary
- If it's a logic error → fix and add regression test
3. Verify the fix doesn't break existing tests
4. Write a test that would have caught this bug
El Patrón de Plantilla
Ideal para generar resultados consistentes.
# New API Endpoint
Create a new API endpoint following our conventions:
## File Structure
- Route handler: `apps/api/src/routes/{resource}/{action}.ts`
- Schema: `apps/api/src/schemas/{resource}.ts`
- Test: `apps/api/src/routes/{resource}/__tests__/{action}.test.ts`
## Required Elements
- Zod schema for request validation
- Authentication middleware
- Rate limiting
- Structured error responses using errorResponse()
- Success responses using successResponse()
- OpenAPI documentation comments
Instalación de Skills de la comunidad
El ecosistema de Claude Code tiene una biblioteca creciente de skills de la comunidad. Instálalas con:
npx add-skill username/repo-name -y
Colecciones de skills populares:
coreyhaines31/marketingskills(29 skills de marketing/SEO)hedging8563/lemondata-api-skill(integración con la API de LemonData)
Las skills instaladas aparecen en ~/.claude/commands/ y funcionan en todos los proyectos.
Los paquetes de skills instalados exponen cada vez más skills reales en lugar de solo markdown de slash command. Si mantienes tu propio repositorio, el patrón de OpenCode + LemonData se aplica aquí también: mantén la skill cerca del flujo de trabajo, no oculta en archivos de prompt ad hoc.
Skills de Proyecto vs Globales
| Ubicación | Alcance | Caso de uso |
|---|---|---|
.claude/skills/ |
Solo este proyecto | Convenciones del proyecto, flujos de trabajo de despliegue |
~/.claude/skills/ |
Todos los proyectos | Preferencias personales, hábitos reutilizables |
.claude/commands/ |
Compatibilidad heredada | Archivos antiguos de slash command que aún funcionan |
Las skills de proyecto deben incluirse en tu repositorio para que todo el equipo se beneficie. Las skills globales son para preferencias personales de flujo de trabajo.
Avanzado: Skills con Hooks
Las skills pueden hacer referencia a hooks (comandos de shell que se ejecutan en eventos específicos) para su cumplimiento automatizado:
# Pre-Commit Check
Before any commit, the following hooks run automatically:
- `pre-commit`: runs typecheck + lint
- `post-commit`: updates changelog
If a hook fails, investigate the error output and fix the issue.
Do not use --no-verify to bypass hooks.
Los hooks mismos se configuran en .claude/settings.json:
{
"hooks": {
"pre-commit": "pnpm typecheck && pnpm lint-staged"
}
}
Aquí es donde las skills se convierten en algo más que fragmentos de prompt. Una configuración de equipo útil suele tener tres capas:
- una skill que le indica a Claude el flujo de trabajo
- hooks que hacen cumplir el flujo de trabajo
- documentación del repositorio que explica el flujo de trabajo a los humanos
Si falta una de esas capas, el sistema se vuelve frágil. Una skill sin hooks se vuelve consultiva. Los hooks sin skills se vuelven opacos. La documentación sin ninguno de los dos se convierte en una política obsoleta que nadie sigue.
Los archivos de soporte son la verdadera mejora
La razón más importante para preferir las skills sobre el antiguo markdown de comandos son los archivos de soporte.
Con un archivo de comando, todo tiene que vivir en un solo bloque. Con un directorio de skill, puedes mantener:
- plantillas
- ejemplos
- ayudantes de shell
- notas de referencia más largas
- scripts de validación
Eso te permite mantener SKILL.md corto y con una señal alta, mientras le das a Claude material estructurado para consultar cuando sea necesario.
Esto es especialmente útil para:
- flujos de trabajo de despliegue
- listas de verificación de migración de esquemas
- procesos de revisión de código de varios pasos
- manuales de integración específicos del producto
Si tu equipo también está utilizando múltiples modelos o múltiples herramientas de codificación, combina esta página con la comparativa de modelos de codificación y la guía de configuración de Cursor / Cline / Windsurf. Las buenas skills importan más cuando el modelo o el editor subyacente cambian.
Consejos para Skills efectivas
Sé específico sobre las rutas de archivos y las convenciones de nomenclatura. "Crear un componente" es vago. "Crear un componente en
src/components/ui/usando la nomenclatura PascalCase" es accionable.Incluye ejemplos de resultados correctos. Claude Code aprende mejor de ejemplos que de reglas abstractas.
Define qué NOT hacer. "Nunca uses el tipo
any" es más fácil de hacer cumplir que "usa tipos adecuados".Mantén las skills enfocadas. Una skill por flujo de trabajo. Una skill de 200 líneas que lo cubra todo es menos útil que cinco skills de 40 líneas que manejen bien una sola tarea.
Versiona tus skills. A medida que tus convenciones evolucionen, actualiza las skills. Las skills desactualizadas son peores que no tener skills porque imponen patrones antiguos.
Decide si la skill debe cargarse automáticamente o solo ejecutarse manualmente. Muchos equipos olvidan esto y luego se preguntan por qué Claude invoca una skill de despliegue en conversaciones no relacionadas.
Impacto en el mundo real
Los equipos que adoptan skills informan mejoras constantes:
- Los ciclos de revisión de código disminuyen porque las convenciones se aplican antes de la revisión
- El tiempo de incorporación disminuye porque los nuevos desarrolladores reciben la misma orientación que los veteranos
- La calidad del código generado por AI mejora porque la AI tiene un contexto explícito sobre los estándares del proyecto
La inversión es pequeña (30 minutos para escribir tus primeras skills) y el beneficio se acumula con cada interacción.
El modelo mental más útil es este: una skill no es un atajo para Claude. Es un artefacto de flujo de trabajo versionado para tu equipo.
Si solo escribes una skill, que sea la que codifique la decisión repetida de mayor costo en tu base de código.
Construye con AI, guiado por tus propias reglas. LemonData te ofrece una API key para modelos de codificación de diversos proveedores, de modo que una vez que tus flujos de trabajo estén codificados como skills, puedas cambiar de modelo sin reconstruir toda la cadena de herramientas.