### Respuesta rápida: ¿Qué son los skills de Claude Code y cómo funcionan?
Los skills de Claude Code son paquetes modulares de capacidades bajo demanda almacenados en
.claude/skills/que reemplazan los prompts de sistema monolíticos. Activados por la intención del modelo o mediante comandos de barra (/SKILL.md /skill-name), ejecutan scripts locales validados, generan subagentes aislados sin sobrecargar el contexto e interactúan sin problemas con los plugins oficiales de JetBrains y VS Code.
1. El cambio arquitectónico: Superando el CLAUDE.md monolítico
En las primeras etapas de la ingeniería de software asistida por IA (2023–2025), los desarrolladores intentaban gobernar a los agentes de codificación autónomos agregando todas las reglas, estándares, esquemas de bases de datos y comandos de compilación en un único archivo monolítico, principalmente CLAUDE.md o .cursorrules.
Para 2026, a medida que las bases de código crecieron a millones de líneas y los agentes evolucionaron hacia modelos de razonamiento multi-turno (Claude 3.7 Sonnet, Claude 4.5 y Claude 4.6), el enfoque monolítico colapsó ante tres limitaciones críticas:
Fallo de configuración monolítica (Antipatrón):
[CLAUDE.md de 200 líneas] ──> Inyectado en CADA turno ──> Desperdicia 8k-15k tokens/prompt
│
├── Dilución del contexto (Pérdida de atención)
├── Invalidación de caché KV y altos costos ($$)
└── Alucinaciones en refactorizaciones complejas- Dilución de la ventana de contexto: Cargar decenas de páginas de directivas estáticas en el contexto activo en cada turno degradaba la atención del LLM sobre el código fuente real.
- Economía de tokens e invalidación de caché: La modificación de una sola línea en el archivo monolítico invalidaba todo el prefijo en caché, perdiendo el descuento del 90% de Prompt Caching.
- Ausencia de validación determinista: Las instrucciones en lenguaje natural no garantizan la validación estricta de argumentos mediante JSON Schema ni la verificación de códigos de salida.
La arquitectura desacoplada en tres niveles
Anthropic adoptó en Claude Code CLI una arquitectura de extensibilidad desacoplada:
+-------------------------------------------------------------------------------+
| Despachador Central de Claude Code |
+-------------------------------------------------------------------------------+
| | |
v v v
+------------------+ +------------------+ +------------------+
| Motor de Skills | | Capa MCP | | Plugins de IDE |
| (.claude/skills) | | (JSON-RPC Tools) | | (JetBrains/VSCode|
+------------------+ +------------------+ +------------------+
| • SOPs estándar | | • BDs externas | | • Diffs en editor|
| • Subagentes | | • APIs de GitHub | | • Índices AST |
| • Scripts locales| | • Infra de nube | | • Sockets IPC |
+------------------+ +------------------+ +------------------+- Skills (
.claude/skills/): Procedimientos operativos estándar (SOP) ligeros que se cargan dinámicamente en el contexto solo cuando son requeridos. - Model Context Protocol (MCP): Conexiones JSON-RPC con estado sobre stdio o SSE para interactuar con bases de datos externas y APIs remotas.
- Plugins de IDE (JetBrains / VS Code): Puentes IPC locales que sincronizan la selección del cursor, diagnósticos sintácticos y diffs interactivos directamente en el editor.
2. Matriz cuantitativa: Skills vs. MCP vs. Subagentes vs. Hooks
| Mecanismo de extensión | Método de ejecución | Latencia añadida | Consumo de tokens en contexto | Nivel de aislamiento | Caso de uso principal |
|---|---|---|---|---|---|
| Skill de Claude Code | SOP bajo demanda (SKILL.md) + script local |
Mínima (<15ms) | Dinámico (~800–2,500t solo al invocarse) | Aislamiento por proceso | Flujos estandarizados, migraciones, auditorías CI |
| Servidor MCP | JSON-RPC 2.0 con estado (stdio/SSE) | Baja (~40–120ms) | Herramientas estáticas en prompt (~1,500t) | Aislamiento de red y proceso | BDs externas, APIs remotas, servicios en la nube |
| Tarea de Subagente | Bucle de contexto secundario aislado | Media (~1.5–3.5s) | 0 tokens añadidos al hilo principal | Espacio de memoria aislado | Exploraciones masivas, refactorizaciones profundas |
| Hook de Ciclo de Vida | Scripts Bash por eventos (pre-commit) |
Casi nula (<5ms) | 0 tokens (Ejecución puramente local) | Entorno de shell del host | Autoformateo, protección de ramas, linters |
| Plugin de JetBrains | Socket IPC bidireccional local | Instantánea (<8ms) | Buffer de viewport activo (~600 tokens) | UI de IDE / Puente editor | Revisión de diffs interactiva, navegación de símbolos |
Rendimiento en Benchmarks y Ahorro Económico
Resultados en un repositorio empresarial estándar (1.8M líneas de TypeScript y Rust; 420 pruebas unitarias; modelos Claude 3.7 Sonnet y Claude 4.5/4.6):
| Configuración | SWE-bench Verified (Tasa de éxito) | LiveCodeBench Pass@1 | Tokens promedio por PR | Costo por PR resuelto ($) | Tasa de acierto de caché |
|---|---|---|---|---|---|
| Claude Code básico (sin skills) | 64.2% | 68.1% | 684,000 | $2.05 | 74.2% |
CLAUDE.md monolítico (reglas masivas) |
61.8% | 65.4% | 895,000 | $2.68 | 51.3% |
| Skills modulares + Subagentes | 74.6% | 73.2% | 412,000 | $1.23 | 94.8% |
| Skills + Sincronización JetBrains + MCP | 76.8% | 74.5% | 445,000 | $1.33 | 93.1% |
El uso de skills modulares incrementa la resolución en SWE-bench en un +12.6% respecto a las configuraciones monolíticas y reduce los costos en un 39.8%.
3. Integración con IDEs de JetBrains: IntelliJ, WebStorm y PyCharm
El plugin oficial de JetBrains enlaza el demonio de terminal de Claude Code con IntelliJ IDEA, PyCharm, WebStorm, GoLand, CLion y RustRover.
Arquitectura del Puente IPC en JetBrains:
+------------------------------------+ Unix Domain Socket / TCP Loopback
| Proceso de IDE JetBrains | <========================================>
| - Archivo activo y selección |
| - Árbol sintáctico PSI (AST) |
| - Ventana interactiva de Diffs |
+------------------------------------+
|
v
+----------------------------------+
| Demonio CLI de Claude Code |
| `claude --daemon --ide-bridge` |
| - Orquestador de subagentes |
| - Motor .claude/skills/ |
+----------------------------------+Capacidades principales
- Sincronización contextual: El archivo activo y la posición del cursor se transmiten en tiempo real sin requerir copiar y pegar.
- Revisión visual de diffs en el editor: Los cambios propuestos se muestran en el comparador nativo de JetBrains, permitiendo aceptar o rechazar fragmentos individuales (
Ctrl+Alt+Y/Cmd+Option+Y). - Consulta del índice PSI (AST): Claude Code utiliza el índice de compilación de IntelliJ para resolver referencias a símbolos 4.2 veces más rápido que con búsquedas grep tradicionales.
Instalación y puesta en marcha
# Instalar Claude Code CLI
npm install -g @anthropic-ai/claude-code
# O en macOS vía Homebrew
brew install claude-code
# Verificar versión (requiere v2.1.3 o superior)
claude --versionEn el IDE de JetBrains:
- Ir a Settings / Preferences -> Plugins.
- Buscar Claude Code en la pestaña Marketplace e instalar.
- Reiniciar el entorno y abrir la ventana lateral de Claude Code (
Cmd+Alt+C). - Verificar el enlace en la terminal integrada:
claude doctor4. Desarrollo práctico: Creación de skills en .claude/skills/ con esquemas estrictos
Raíz del repositorio/
├── .claude/
│ ├── config.json
│ └── skills/
│ └── db-migration-validator/
│ ├── SKILL.md # Punto de entrada e instrucciones
│ ├── schema.json # Validación de argumentos JSON Schema
│ └── scripts/
│ └── validate.py # Script de validación deterministaEstructura de SKILL.md
---
name: db-migration-validator
description: Valida migraciones SQL/ORM contra bloqueos exclusivos de tablas y compatibilidad.
version: "1.2.0"
author: "Platform Engineering"
disable_auto_invoke: false
inputSchema:
type: object
properties:
migration_file:
type: string
description: Ruta relativa al archivo de migración.
pattern: "^(migrations|prisma|drizzle)/.*\.(sql|ts)$"
safety_level:
type: string
enum: ["strict", "permissive"]
default: "strict"
description: "strict bloquea cualquier bloqueo ACCESS EXCLUSIVE en tablas."
required: ["migration_file"]
---
# Protocolo de validación de migraciones
Está ejecutando el skill **db-migration-validator**.
1. **Lectura de esquema**: Analice el archivo indicado en `{{migration_file}}`.
2. **Ejecución del script determinista**:
Ejecute el validador local antes de responder:
```bash
python3 .claude/skills/db-migration-validator/scripts/validate.py \
--file "{{migration_file}}" \
--level "{{safety_level}}"
```
3. **Análisis de bloqueos**:
- Comprobar reescritura de tablas (`ALTER TABLE ... ADD COLUMN ... NOT NULL` sin default).
- Verificar si los índices en Postgres usan `CONCURRENTLY`.
4. **Resumen estructurado**:
- Emitir tabla con nivel de riesgo, tipo de bloqueo y reversibilidad.Script de validación determinista scripts/validate.py
#!/usr/bin/env python3
# Deterministic migration validator
import argparse
import json
import re
import sys
HAZARDS = [
(r"ALTER\s+TABLE\s+\w+\s+ADD\s+COLUMN\s+\w+.*NOT\s+NULL", "Bloqueo ACCESS EXCLUSIVE con reescritura de tabla"),
(r"CREATE\s+INDEX\s+(?!CONCURRENTLY)", "Índice sin CONCURRENTLY bloquea escrituras concurrentes"),
(r"DROP\s+TABLE\s+", "Eliminación destructiva de tabla sin archivado"),
(r"RENAME\s+COLUMN\s+", "Renombrar columna rompe consultas en ejecución"),
]
def check_migration(filepath: str, level: str):
violations = []
with open(filepath, "r", encoding="utf-8") as f:
content = f.read()
for pattern, warning in HAZARDS:
matches = re.finditer(pattern, content, re.IGNORECASE)
for m in matches:
line_no = content[:m.start()].count("\n") + 1
violations.append({"line": line_no, "hazard": warning, "snippet": m.group(0)})
result = {
"file": filepath,
"violations": violations,
"status": "FAILED" if (violations and level == "strict") else "PASSED"
}
print(json.dumps(result, indent=2))
if violations and level == "strict":
sys.exit(1)
sys.exit(0)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--file", required=True)
parser.add_argument("--level", default="strict")
args = parser.parse_args()
check_migration(args.file, args.level)5. Orquestación avanzada de subagentes en skills
Patrón de delegación de subagentes:
+-------------------------------------------------------------------------+
| Hilo principal del agente (Contexto limpio: 14k tokens) |
| > /security-audit |
+-------------------------------------------------------------------------+
|
| 1. Inicia subagente aislado (Contexto arranca en 0 tokens)
v
+-------------------------------------------------------------------------+
| Subagente: "SecurityScanner" (Analiza 42 archivos, consume 180k tokens) |
| - Ejecuta AST-grep, traza grafos de vulnerabilidades |
| - Genera un informe JSON estructurado y limpio |
+-------------------------------------------------------------------------+
|
| 2. Devuelve únicamente el resumen comprimido (~1.2k tokens)
v
+-------------------------------------------------------------------------+
| Hilo principal del agente (Se mantiene en solo 15.2k tokens) |
| - Revisa las 3 vulnerabilidades críticas encontradas |
| - Genera parches precisos sin saturar la memoria de trabajo |
+-------------------------------------------------------------------------+6. Top 10 Skills recomendados para entornos de producción en 2026
pr-security-auditor: Análisis estático en el diff de Git para prevenir fugas de credenciales e inyecciones.git-atomic-committer: Divide modificaciones complejas en commits atómicos debidamente probados.db-migration-guard: Validador de bloqueos de tablas para Postgres, Prisma y Drizzle.playwright-e2e-verifier: Pruebas visuales e2e en navegador headless previas a la confirmación de cambios.openapi-contract-sync: Verifica la concordancia entre controladores y esquemas OpenAPI.ast-grep-codemod: Refactorización masiva multiactivo asistida por árboles de sintaxis.docker-rootless-linter: Auditoría de contenedores sin privilegios de root y escaneo de vulnerabilidades.prompt-cache-profiler: Monitoreo de ratios de acierto de caché de tokens y costos asociados.jetbrains-symbol-bridge: Conexión directa con el índice de compilación de JetBrains para búsqueda de símbolos.pnpm-turborepo-orchestrator: Control de versiones y resolución de dependencias en monorrepositorios.
7. Economía de tokens, caché de prompts y seguridad
Conservación del 90% de descuento en caché
Mantener un prefijo de instrucciones estable y añadir skills únicamente cuando se ejecutan permite alcanzar tasas de acierto en caché del 92% al 96%, reduciendo el gasto medio por tarea de $2.40 a $1.25.
Configuración de permisos
Establezca un entorno protegido mediante .claude/permissions.json:
{
"permissions": {
"allow_shell_commands": [
"git status",
"git diff",
"pnpm test *",
"python3 .claude/skills/*"
],
"deny_shell_commands": [
"rm -rf /",
"curl * | bash",
"sudo *"
],
"require_human_confirmation": [
"git push *",
"npm publish",
"docker run *"
]
},
"skill_isolation": {
"network_access": "restricted",
"timeout_seconds": 60
}
}8. Hoja de ruta para equipos de desarrollo
- Semana 1: Depuración: Reducir los archivos
CLAUDE.mda directrices generales de menos de 100 líneas. - Semana 2: Estandarización de IDE: Desplegar los plugins de JetBrains y VS Code en todo el equipo.
- Semana 3: Adopción de skills clave: Implementar
pr-security-auditorydb-migration-guard. - Semana 4: Escalado con subagentes: Configurar flujos paralelos de subagentes para monorrepositorios.