Ampliar Claude con skills

Crear, gestionar y compartir skills para ampliar las capacidades de Claude en Claude Code. Incluye comandos personalizados y skills agrupados.

Los skills amplían lo que Claude puede hacer. Cree un archivo SKILL.md con instrucciones, y Claude lo añade a su kit de herramientas. Claude utiliza skills cuando es relevante, o puede invocar uno directamente con /skill-name.

Cree un skill cuando siga pegando el mismo manual, lista de verificación o procedimiento de varios pasos en el chat, o cuando una sección de CLAUDE.md se haya convertido en un procedimiento en lugar de un hecho. A diferencia del contenido de CLAUDE.md, el cuerpo de un skill se carga solo cuando se usa, por lo que el material de referencia largo cuesta casi nada hasta que lo necesita.

Los skills de Claude Code siguen el estándar abierto Agent Skills, que funciona en múltiples herramientas de IA. Claude Code extiende el estándar con características adicionales como control de invocación, ejecución de subagent, e inyección de contexto dinámico.

Skills agrupados

Claude Code incluye un conjunto de skills agrupados que están disponibles en cada sesión, incluyendo /simplify, /batch, /debug, /loop y /claude-api. A diferencia de la mayoría de comandos integrados, que ejecutan lógica fija directamente, los skills agrupados se basan en prompts: dan a Claude un manual detallado y le permiten orquestar el trabajo utilizando sus herramientas. Los invoca de la misma manera que cualquier otro skill, escribiendo / seguido del nombre del skill.

Los skills agrupados se enumeran junto con los comandos integrados en la referencia de comandos, marcados como Skill en la columna Propósito.

Primeros pasos

Crear su primer skill

Este ejemplo crea un skill que resume los cambios sin confirmar en su repositorio git e identifica cualquier cosa arriesgada. Extrae el diff en vivo en el prompt antes de que Claude lo lea, por lo que la respuesta se basa en su árbol de trabajo real en lugar de lo que Claude puede adivinar a partir de archivos abiertos. Claude carga el skill automáticamente cuando pregunta sobre sus cambios, o puede invocarlo directamente con /summarize-changes.

mkdir -p ~/.claude/skills/summarize-changes

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

What did I change?

/summarize-changes

Dónde viven los skills

Dónde almacena un skill determina quién puede usarlo:

Cuando los skills comparten el mismo nombre en diferentes niveles, enterprise anula personal, y personal anula proyecto. Los skills de plugin utilizan un espacio de nombres plugin-name:skill-name, por lo que no pueden entrar en conflicto con otros niveles. Si tiene archivos en .claude/commands/, funcionan de la misma manera, pero si un skill y un comando comparten el mismo nombre, el skill tiene prioridad.

Detección de cambios en vivo

Claude Code observa los directorios de skills para detectar cambios de archivos. Añadir, editar o eliminar un skill bajo ~/.claude/skills/, el proyecto .claude/skills/, o un .claude/skills/ dentro de un directorio --add-dir surte efecto dentro de la sesión actual sin reiniciar. Crear un directorio de skills de nivel superior que no existía cuando se inició la sesión requiere reiniciar Claude Code para que el nuevo directorio pueda ser observado.

Descubrimiento automático desde directorios anidados y padres

Los skills del proyecto se cargan desde .claude/skills/ en su directorio de inicio y en cada directorio padre hasta la raíz del repositorio, por lo que iniciar Claude en un subdirectorio sigue recogiendo skills definidos en la raíz. Cuando trabaja con archivos en subdirectorios por debajo de su directorio de inicio, Claude Code también descubre skills desde directorios .claude/skills/ anidados bajo demanda. Por ejemplo, si está editando un archivo en packages/frontend/, Claude Code también busca skills en packages/frontend/.claude/skills/. Esto admite configuraciones de monorepo donde los paquetes tienen sus propios skills.

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

my-skill/
├── SKILL.md           # Main instructions (required)
├── template.md        # Template for Claude to fill in
├── examples/
│   └── sample.md      # Example output showing expected format
└── scripts/
    └── validate.sh    # Script Claude can execute

El SKILL.md contiene las instrucciones principales y es obligatorio. Otros archivos son opcionales y le permiten crear skills más potentes: plantillas para que Claude las complete, salidas de ejemplo que muestren el formato esperado, scripts que Claude pueda ejecutar o documentación de referencia detallada. Haga referencia a estos archivos desde su SKILL.md para que Claude sepa qué contienen y cuándo cargarlos. Consulte Añadir archivos de apoyo para más detalles.

Skills de directorios adicionales

La bandera --add-dir otorga acceso a archivos en lugar de descubrimiento de configuración, pero los skills son una excepción: .claude/skills/ dentro de un directorio añadido se carga automáticamente. Consulte Detección de cambios en vivo para ver cómo se detectan las ediciones durante una sesión.

Otra configuración de .claude/ como subagents, comandos y estilos de salida no se carga desde directorios adicionales. Consulte la tabla de excepciones para la lista completa de qué se carga y qué no, y las formas recomendadas de compartir configuración entre proyectos.

Configurar skills

Los skills se configuran a través de frontmatter YAML en la parte superior de SKILL.md y el contenido markdown que sigue.

Tipos de contenido de skill

Los archivos de skill pueden contener cualquier instrucción, pero pensar en cómo desea invocarlos ayuda a guiar qué incluir:

Contenido de referencia añade conocimiento que Claude aplica a su trabajo actual. Convenciones, patrones, guías de estilo, conocimiento del dominio. Este contenido se ejecuta en línea para que Claude pueda usarlo junto con el contexto de su conversación.

---
name: api-conventions
description: API design patterns for this codebase
---

When writing API endpoints:
- Use RESTful naming conventions
- Return consistent error formats
- Include request validation

Contenido de tarea da a Claude instrucciones paso a paso para una acción específica, como despliegues, commits o generación de código. Estas son a menudo acciones que desea invocar directamente con /skill-name en lugar de dejar que Claude decida cuándo ejecutarlas. Añada disable-model-invocation: true para evitar que Claude la active automáticamente.

---
name: deploy
description: Deploy the application to production
context: fork
disable-model-invocation: true
---

Deploy the application:
1. Run the test suite
2. Build the application
3. Push to the deployment target

Su SKILL.md puede contener cualquier cosa, pero pensar en cómo desea que se invoque el skill (por usted, por Claude, o ambos) y dónde desea que se ejecute (en línea o en un subagent) ayuda a guiar qué incluir. Para skills complejos, también puede añadir archivos de apoyo para mantener el skill principal enfocado.

Mantenga el cuerpo en sí conciso. Una vez que se carga un skill, su contenido permanece en contexto entre turnos, por lo que cada línea es un costo de token recurrente. Indique qué hacer en lugar de narrar cómo o por qué, y aplique la misma prueba de concisión que haría para contenido de CLAUDE.md.

Referencia de frontmatter

Más allá del contenido markdown, puede configurar el comportamiento del skill utilizando campos de frontmatter YAML entre marcadores --- en la parte superior de su archivo SKILL.md:

---
name: my-skill
description: What this skill does
disable-model-invocation: true
allowed-tools: Read Grep
---

Your skill instructions here...

Todos los campos son opcionales. Solo se recomienda description para que Claude sepa cuándo usar el skill.

Sustituciones de cadena disponibles

Los skills admiten sustitución de cadena para valores dinámicos en el contenido del skill:

Los argumentos indexados utilizan entrecomillado de estilo shell, por lo que envuelva valores de varias palabras entre comillas para pasarlos como un único argumento. Por ejemplo, /my-skill "hello world" second hace que $0 se expanda a hello world y $1 a second. El marcador de posición $ARGUMENTS siempre se expande a la cadena de argumento completa tal como se escribió.

Ejemplo usando sustituciones:

---
name: session-logger
description: Log activity for this session
---

Log the following to logs/${CLAUDE_SESSION_ID}.log:

$ARGUMENTS

Añadir archivos de apoyo

Los skills pueden incluir múltiples archivos en su directorio. Esto mantiene SKILL.md enfocado en lo esencial mientras permite que Claude acceda a material de referencia detallado solo cuando sea necesario. Documentos de referencia grandes, especificaciones de API o colecciones de ejemplos no necesitan cargarse en contexto cada vez que se ejecuta el skill.

my-skill/
├── SKILL.md (required - overview and navigation)
├── reference.md (detailed API docs - loaded when needed)
├── examples.md (usage examples - loaded when needed)
└── scripts/
    └── helper.py (utility script - executed, not loaded)

Haga referencia a archivos de apoyo desde SKILL.md para que Claude sepa qué contiene cada archivo y cuándo cargarlo:

## Additional resources

- For complete API details, see [reference.md](/anthropic/claude-code/history/docs/es/2026-05-15-2258..2026-05-17-0101/reference/)
- For usage examples, see [examples.md](/anthropic/claude-code/history/docs/es/2026-05-15-2258..2026-05-17-0101/examples/)

Controlar quién invoca un skill

De forma predeterminada, tanto usted como Claude pueden invocar cualquier skill. Puede escribir /skill-name para invocarlo directamente, y Claude puede cargarlo automáticamente cuando sea relevante para su conversación. Dos campos de frontmatter le permiten restringir esto:

• disable-model-invocation: true: Solo usted puede invocar el skill. Utilice esto para flujos de trabajo con efectos secundarios o que desea controlar el tiempo, como /commit, /deploy o /send-slack-message. No desea que Claude decida desplegar porque su código se ve listo.

• user-invocable: false: Solo Claude puede invocar el skill. Utilice esto para conocimiento de fondo que no es accionable como comando. Un skill legacy-system-context explica cómo funciona un sistema antiguo. Claude debe saber esto cuando sea relevante, pero /legacy-system-context no es una acción significativa para que los usuarios realicen.

Este ejemplo crea un skill de despliegue que solo usted puede activar. El campo disable-model-invocation: true evita que Claude lo ejecute automáticamente:

---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
---

Deploy $ARGUMENTS to production:

1. Run the test suite
2. Build the application
3. Push to the deployment target
4. Verify the deployment succeeded

Aquí se muestra cómo los dos campos afectan la invocación y la carga de contexto:

Ciclo de vida del contenido del skill

Cuando usted o Claude invoca un skill, el contenido SKILL.md renderizado entra en la conversación como un único mensaje y permanece allí durante el resto de la sesión. Claude Code no vuelve a leer el archivo de skill en turnos posteriores, por lo que escriba la orientación que debe aplicarse durante una tarea como instrucciones permanentes en lugar de pasos únicos.

Auto-compactación lleva skills invocados hacia adelante dentro de un presupuesto de tokens. Cuando la conversación se resume para liberar contexto, Claude Code vuelve a adjuntar la invocación más reciente de cada skill después del resumen, manteniendo los primeros 5.000 tokens de cada uno. Los skills reajustados comparten un presupuesto combinado de 25.000 tokens. Claude Code llena este presupuesto comenzando desde el skill invocado más recientemente, por lo que los skills más antiguos pueden eliminarse completamente después de la compactación si ha invocado muchos en una sesión.

Si un skill parece dejar de influir en el comportamiento después de la primera respuesta, el contenido generalmente sigue presente y el modelo está eligiendo otras herramientas o enfoques. Fortalezca la description del skill e instrucciones para que el modelo siga prefiriéndolo, o use hooks para aplicar comportamiento de manera determinista. Si el skill es grande o invocó varios otros después de él, vuelva a invocarlo después de la compactación para restaurar el contenido completo.

Pre-aprobar herramientas para un skill

El campo allowed-tools otorga permiso para las herramientas enumeradas mientras el skill está activo, por lo que Claude puede usarlas sin solicitarle aprobación. No restringe qué herramientas están disponibles: cada herramienta sigue siendo invocable, y su configuración de permisos sigue rigiendo las herramientas que no están enumeradas.

Para skills verificados en el directorio .claude/skills/ de un proyecto, allowed-tools entra en vigor después de que acepte el diálogo de confianza del espacio de trabajo para esa carpeta, igual que las reglas de permisos en .claude/settings.json. Revise los skills del proyecto antes de confiar en un repositorio, ya que un skill puede otorgarse a sí mismo acceso amplio a herramientas.

Este skill permite que Claude ejecute comandos git sin aprobación por uso cada vez que lo invoca:

---
name: commit
description: Stage and commit the current changes
disable-model-invocation: true
allowed-tools: Bash(git add *) Bash(git commit *) Bash(git status *)
---

Para bloquear un skill de usar ciertas herramientas, añada reglas de denegación en su configuración de permisos en su lugar.

Pasar argumentos a skills

Tanto usted como Claude pueden pasar argumentos al invocar un skill. Los argumentos están disponibles a través del marcador de posición $ARGUMENTS.

Este skill corrige un problema de GitHub por número. El marcador de posición $ARGUMENTS se reemplaza con lo que sigue al nombre del skill:

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---

Fix GitHub issue $ARGUMENTS following our coding standards.

1. Read the issue description
2. Understand the requirements
3. Implement the fix
4. Write tests
5. Create a commit

Cuando ejecuta /fix-issue 123, Claude recibe "Fix GitHub issue 123 following our coding standards..."

Si invoca un skill con argumentos pero el skill no incluye $ARGUMENTS, Claude Code añade ARGUMENTS: <your input> al final del contenido del skill para que Claude siga viendo lo que escribió.

Para acceder a argumentos individuales por posición, utilice $ARGUMENTS[N] o la forma más corta $N:

---
name: migrate-component
description: Migrate a component from one framework to another
---

Migrate the $ARGUMENTS[0] component from $ARGUMENTS[1] to $ARGUMENTS[2].
Preserve all existing behavior and tests.

Ejecutar /migrate-component SearchBar React Vue reemplaza $ARGUMENTS[0] con SearchBar, $ARGUMENTS[1] con React y $ARGUMENTS[2] con Vue. El mismo skill usando la abreviatura $N:

---
name: migrate-component
description: Migrate a component from one framework to another
---

Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.

Patrones avanzados

Inyectar contexto dinámico

La sintaxis !`<command>` ejecuta comandos de shell antes de que el contenido del skill se envíe a Claude. La salida del comando reemplaza el marcador de posición, por lo que Claude recibe datos reales, no el comando en sí.

Este skill resume una solicitud de extracción obteniendo datos de PR en vivo con la CLI de GitHub. Los comandos !`gh pr diff` y otros se ejecutan primero, y su salida se inserta en el prompt:

---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---

## Pull request context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task
Summarize this pull request...

Cuando se ejecuta este skill:

1. Cada !`<command>` se ejecuta inmediatamente (antes de que Claude vea algo)
2. La salida reemplaza el marcador de posición en el contenido del skill
3. Claude recibe el prompt completamente renderizado con datos de PR reales

Esto es preprocesamiento, no algo que Claude ejecute. Claude solo ve el resultado final.

La sustitución se ejecuta una sola vez sobre el archivo original. La salida del comando se inserta como texto sin formato y no se vuelve a escanear para buscar más marcadores de posición !`<command>`, por lo que un comando no puede emitir un marcador de posición para que una pasada posterior lo expanda.

Para comandos de varias líneas, utilice un bloque de código cercado abierto con ```! en lugar de la forma en línea:

## Environment
```!
node --version
npm --version
git status --short
```

Para deshabilitar este comportamiento para skills y comandos personalizados de fuentes de usuario, proyecto, plugin o directorio adicional, establezca "disableSkillShellExecution": true en settings. Cada comando se reemplaza con [shell command execution disabled by policy] en lugar de ejecutarse. Los skills agrupados y gestionados no se ven afectados. Esta configuración es más útil en managed settings, donde los usuarios no pueden anularla.

Ejecutar skills en un subagent

Añada context: fork a su frontmatter cuando desee que un skill se ejecute en aislamiento. El contenido del skill se convierte en el prompt que impulsa el subagent. No tendrá acceso a su historial de conversación.

Los skills y los subagents funcionan juntos en dos direcciones:

Con context: fork, escribe la tarea en tu skill y elige un tipo de agent para ejecutarla. Para lo inverso (definir un subagent personalizado que use skills como material de referencia), consulte Subagents.

Ejemplo: Skill de investigación usando agent Explore

Este skill ejecuta investigación en un agent Explore bifurcado. El contenido del skill se convierte en la tarea, y el agent proporciona herramientas de solo lectura optimizadas para exploración de base de código:

---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---

Research $ARGUMENTS thoroughly:

1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references

Cuando se ejecuta este skill:

1. Se crea un nuevo contexto aislado
2. El subagent recibe el contenido del skill como su prompt ("Research $ARGUMENTS thoroughly...")
3. El campo agent determina el entorno de ejecución (modelo, herramientas y permisos)
4. Los resultados se resumen y se devuelven a su conversación principal

El campo agent especifica qué configuración de subagent usar. Las opciones incluyen agents integrados (Explore, Plan, general-purpose) o cualquier subagent personalizado de .claude/agents/. Si se omite, utiliza general-purpose.

Restringir el acceso de Claude a skills

De forma predeterminada, Claude puede invocar cualquier skill que no tenga disable-model-invocation: true establecido. Los skills que definen allowed-tools otorgan a Claude acceso a esas herramientas sin aprobación por uso cuando el skill está activo. Su configuración de permisos sigue rigiendo el comportamiento de aprobación de línea base para todas las demás herramientas. Algunos comandos integrados también están disponibles a través de la herramienta Skill, incluyendo /init, /review y /security-review. Otros comandos integrados como /compact no lo están.

Tres formas de controlar qué skills puede invocar Claude:

Deshabilitar todos los skills negando la herramienta Skill en /permissions:

# Add to deny rules:
Skill

Permitir o denegar skills específicos usando reglas de permisos:

# Allow only specific skills
Skill(commit)
Skill(review-pr *)

# Deny specific skills
Skill(deploy *)

Sintaxis de permisos: Skill(name) para coincidencia exacta, Skill(name *) para coincidencia de prefijo con cualquier argumento.

Ocultar skills individuales añadiendo disable-model-invocation: true a su frontmatter. Esto elimina el skill del contexto de Claude por completo.

Anular la visibilidad del skill desde la configuración

La configuración skillOverrides controla la visibilidad del skill desde su settings en lugar del frontmatter del skill. Úselo para skills cuyo SKILL.md no desea editar, como los que se registran en un repositorio de proyecto compartido o proporcionados por un servidor MCP. El menú /skills lo escribe por usted: resalte un skill y presione Space para ciclar entre estados, luego Enter para guardar en .claude/settings.local.json.

Cada clave es un nombre de skill y cada valor es uno de cuatro estados:

Un skill que está ausente de skillOverrides se trata como "on". El ejemplo a continuación colapsa un skill a su nombre y desactiva otro por completo:

{
  "skillOverrides": {
    "legacy-context": "name-only",
    "deploy": "off"
  }
}

Los skills de plugin no se ven afectados por skillOverrides. Gestione esos a través de /plugin en su lugar.

Compartir skills

Los skills se pueden distribuir en diferentes ámbitos dependiendo de su audiencia:

• Skills de proyecto: Confirme .claude/skills/ en el control de versiones
• Plugins: Cree un directorio skills/ en su plugin
• Gestionado: Implemente en toda la organización a través de configuración gestionada

Generar salida visual

Los skills pueden agrupar y ejecutar scripts en cualquier idioma, dando a Claude capacidades más allá de lo que es posible en un único prompt. Un patrón poderoso es generar salida visual: archivos HTML interactivos que se abren en su navegador para explorar datos, depurar o crear informes.

Este ejemplo crea un explorador de base de código: una vista de árbol interactiva donde puede expandir y contraer directorios, ver tamaños de archivo de un vistazo e identificar tipos de archivo por color.

Cree el directorio Skill:

mkdir -p ~/.claude/skills/codebase-visualizer/scripts

Guarde esto en ~/.claude/skills/codebase-visualizer/SKILL.md. La descripción le dice a Claude cuándo activar este Skill, y las instrucciones le dicen a Claude que ejecute el script incluido. La ruta del script utiliza ${CLAUDE_SKILL_DIR} para que se resuelva correctamente si el skill está instalado a nivel personal, de proyecto o de plugin:

---
name: codebase-visualizer
description: Generate an interactive collapsible tree visualization of your codebase. Use when exploring a new repo, understanding project structure, or identifying large files.
allowed-tools: Bash(python3 *)
---

# Codebase Visualizer

Generate an interactive HTML tree view that shows your project's file structure with collapsible directories.

## Usage

Run the visualization script from your project root:

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/visualize.py .
```

This creates `codebase-map.html` in the current directory and opens it in your default browser.

## What the visualization shows

- **Collapsible directories**: Click folders to expand/collapse
- **File sizes**: Displayed next to each file
- **Colors**: Different colors for different file types
- **Directory totals**: Shows aggregate size of each folder

Guarde esto en ~/.claude/skills/codebase-visualizer/scripts/visualize.py. Este script escanea un árbol de directorios y genera un archivo HTML independiente con:

• Una barra lateral de resumen que muestra el recuento de archivos, recuento de directorios, tamaño total y número de tipos de archivo
• Un gráfico de barras que desglosa la base de código por tipo de archivo (los 8 principales por tamaño)
• Un árbol contraíble donde puede expandir y contraer directorios, con indicadores de tipo de archivo codificados por color

El script requiere Python 3 pero utiliza solo bibliotecas integradas, por lo que no hay paquetes para instalar:

#!/usr/bin/env python3
"""Generate an interactive collapsible tree visualization of a codebase."""

import json
import sys
import webbrowser
from html import escape
from pathlib import Path
from collections import Counter

IGNORE = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'dist', 'build'}

def scan(path: Path, stats: dict) -> dict:
    result = {"name": path.name, "children": [], "size": 0}
    try:
        for item in sorted(path.iterdir()):
            if item.name in IGNORE or item.name.startswith('.'):
                continue
            if item.is_file():
                size = item.stat().st_size
                ext = item.suffix.lower() or '(no ext)'
                result["children"].append({"name": item.name, "size": size, "ext": ext})
                result["size"] += size
                stats["files"] += 1
                stats["extensions"][ext] += 1
                stats["ext_sizes"][ext] += size
            elif item.is_dir():
                stats["dirs"] += 1
                child = scan(item, stats)
                if child["children"]:
                    result["children"].append(child)
                    result["size"] += child["size"]
    except PermissionError:
        pass
    return result

def generate_html(data: dict, stats: dict, output: Path) -> None:
    ext_sizes = stats["ext_sizes"]
    total_size = sum(ext_sizes.values()) or 1
    sorted_exts = sorted(ext_sizes.items(), key=lambda x: -x[1])[:8]
    colors = {
        '.js': '#f7df1e', '.ts': '#3178c6', '.py': '#3776ab', '.go': '#00add8',
        '.rs': '#dea584', '.rb': '#cc342d', '.css': '#264de4', '.html': '#e34c26',
        '.json': '#6b7280', '.md': '#083fa1', '.yaml': '#cb171e', '.yml': '#cb171e',
        '.mdx': '#083fa1', '.tsx': '#3178c6', '.jsx': '#61dafb', '.sh': '#4eaa25',
    }
    lang_bars = "".join(
        f'<div class="bar-row"><span class="bar-label">{ext}</span>'
        f'<div class="bar" style="width:{(size/total_size)*100}%;background:{colors.get(ext,"#6b7280")}"></div>'
        f'<span class="bar-pct">{(size/total_size)*100:.1f}%</span></div>'
        for ext, size in sorted_exts
    )
    def fmt(b):
        if b < 1024: return f"{b} B"
        if b < 1048576: return f"{b/1024:.1f} KB"
        return f"{b/1048576:.1f} MB"

    html = f'''<!DOCTYPE html>
<html><head>
  <meta charset="utf-8"><title>Codebase Explorer</title>
  <style>
    body {{ font: 14px/1.5 system-ui, sans-serif; margin: 0; background: #1a1a2e; color: #eee; }}
    .container {{ display: flex; height: 100vh; }}
    .sidebar {{ width: 280px; background: #252542; padding: 20px; border-right: 1px solid #3d3d5c; overflow-y: auto; flex-shrink: 0; }}
    .main {{ flex: 1; padding: 20px; overflow-y: auto; }}
    h1 {{ margin: 0 0 10px 0; font-size: 18px; }}
    h2 {{ margin: 20px 0 10px 0; font-size: 14px; color: #888; text-transform: uppercase; }}
    .stat {{ display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #3d3d5c; }}
    .stat-value {{ font-weight: bold; }}
    .bar-row {{ display: flex; align-items: center; margin: 6px 0; }}
    .bar-label {{ width: 55px; font-size: 12px; color: #aaa; }}
    .bar {{ height: 18px; border-radius: 3px; }}
    .bar-pct {{ margin-left: 8px; font-size: 12px; color: #666; }}
    .tree {{ list-style: none; padding-left: 20px; }}
    details {{ cursor: pointer; }}
    summary {{ padding: 4px 8px; border-radius: 4px; }}
    summary:hover {{ background: #2d2d44; }}
    .folder {{ color: #ffd700; }}
    .file {{ display: flex; align-items: center; padding: 4px 8px; border-radius: 4px; }}
    .file:hover {{ background: #2d2d44; }}
    .size {{ color: #888; margin-left: auto; font-size: 12px; }}
    .dot {{ width: 8px; height: 8px; border-radius: 50%; margin-right: 8px; }}
  </style>
</head><body>
  <div class="container">
    <div class="sidebar">
      <h1>📊 Summary</h1>
      <div class="stat"><span>Files</span><span class="stat-value">{stats["files"]:,}</span></div>
      <div class="stat"><span>Directories</span><span class="stat-value">{stats["dirs"]:,}</span></div>
      <div class="stat"><span>Total size</span><span class="stat-value">{fmt(data["size"])}</span></div>
      <div class="stat"><span>File types</span><span class="stat-value">{len(stats["extensions"])}</span></div>
      <h2>By file type</h2>
      {lang_bars}
    </div>
    <div class="main">
      <h1>📁 {escape(data["name"])}</h1>
      <ul class="tree" id="root"></ul>
    </div>
  </div>
</body></html>'''
    output.write_text(html)

if __name__ == '__main__':
    target = Path(sys.argv[1] if len(sys.argv) > 1 else '.').resolve()
    stats = {"files": 0, "dirs": 0, "extensions": Counter(), "ext_sizes": Counter()}
    data = scan(target, stats)
    out = Path('codebase-map.html')
    generate_html(data, stats, out)
    print(f'Generated {out.absolute()}')
    webbrowser.open(f'file://{out.absolute()}')

Para probar, abra Claude Code en cualquier proyecto y pregunte "Visualize this codebase." Claude ejecuta el script, genera codebase-map.html y lo abre en su navegador.

Este patrón funciona para cualquier salida visual: gráficos de dependencias, informes de cobertura de pruebas, documentación de API o visualizaciones de esquema de base de datos. El script incluido hace el trabajo pesado mientras Claude maneja la orquestación.

Solución de problemas

Skill no se activa

Si Claude no usa su skill cuando se espera:

1. Verifique que la descripción incluya palabras clave que los usuarios dirían naturalmente
2. Verifique que el skill aparezca en What skills are available?
3. Intente reformular su solicitud para que coincida más estrechamente con la descripción
4. Invóquelo directamente con /skill-name si el skill es invocable por el usuario

Skill se activa demasiado a menudo

Si Claude usa su skill cuando no desea:

1. Haga la descripción más específica
2. Añada disable-model-invocation: true si solo desea invocación manual

Las descripciones de skills se cortan

Las descripciones de skills se cargan en contexto para que Claude sepa qué está disponible. Todos los nombres de skills siempre se incluyen, pero si tiene muchos skills, las descripciones se acortan para ajustarse al presupuesto de caracteres, lo que puede eliminar las palabras clave que Claude necesita para coincidir con su solicitud. El presupuesto se escala al 1% de la ventana de contexto del modelo. Cuando se desborda, las descripciones de los skills que invoca menos se eliminan primero, por lo que los skills que realmente usa mantienen su texto completo. Ejecute /doctor para ver si el presupuesto se está desbordando y qué skills se ven afectados.

Para aumentar el presupuesto, establezca la configuración skillListingBudgetFraction (por ejemplo, 0.02 = 2%) o la variable de entorno SLASH_COMMAND_TOOL_CHAR_BUDGET a un recuento de caracteres fijo. Para liberar presupuesto para otros skills, establezca las entradas de baja prioridad en "name-only" en skillOverrides para que se enumeren sin descripción. También puede recortar el texto de description y when_to_use en la fuente: coloque el caso de uso clave primero, ya que el texto combinado de cada entrada está limitado a 1.536 caracteres independientemente del presupuesto. El límite es configurable con maxSkillDescriptionChars.

Recursos relacionados

• Depura tu configuración: diagnostica por qué una skill no aparece o no se activa
• Subagents: delega tareas a agents especializados
• Plugins: empaqueta y distribuye skills con otras extensiones
• Hooks: automatiza flujos de trabajo alrededor de eventos de herramientas
• Memory: gestiona archivos CLAUDE.md para contexto persistente
• Comandos: referencia para comandos integrados y skills agrupados
• Permisos: controla el acceso a herramientas y skills