Manuel Navarro Hidalgo.

TUTORIAL CLAUDE CODE DOCS.

Descripción general

> Claude Code es una herramienta de codificación

agencial que lee tu base de código, edita archivos,
ejecuta comandos e integra con tus herramientas de
desarrollo. Disponible en tu terminal, IDE, aplicación
de escritorio y navegador.

Claude Code es un asistente de codificación

impulsado por IA que te ayuda a construir
características, corregir errores y automatizar tareas
de desarrollo. Entiende tu base de código completa
y puede trabajar en múltiples archivos y
herramientas para lograr las cosas.
<h2 id="get-started">
Comenzar
</h2>

Elige tu entorno para comenzar. La mayoría de las

superficies requieren una [suscripción a
Claude]([Link]
ude_code\&utm_medium=docs\&utm_content=overv
iew_pricing) o una cuenta de [Anthropic
Console]([Link] La CLI de
Terminal y VS Code también admiten [proveedores
de terceros](/es/third-party-integrations).

<Tabs>
<Tab title="Terminal">
La CLI completa para trabajar con Claude Code
directamente en tu terminal. Edita archivos, ejecuta
comandos y gestiona tu proyecto completo desde la
línea de comandos.

To install Claude Code, use one of the following

methods:

<Tabs>
<Tab title="Native Install (Recommended)">
**macOS, Linux, WSL:**

```bash theme={null}
curl -fsSL [Link] | bash
Manuel Navarro Hidalgo.
```

**Windows PowerShell:**

```powershell theme={null}
irm [Link] | iex
```

**Windows CMD:**

```batch theme={null}
curl -fsSL [Link] -o
[Link] && [Link] && del [Link]
```

If you see `The token '&&' is not a valid

statement separator`, you're in PowerShell, not
CMD. If you see `'irm' is not recognized as an
internal or external command`, you're in CMD, not
PowerShell. Your prompt shows `PS C:\` when
you're in PowerShell and `C:\` without the `PS` when
you're in CMD.

If the install command fails with `syntax error

near unexpected token '<'`, a `403`, or another curl
error, see [Troubleshoot
installation](/en/troubleshoot-install#find-your-error)
to match the error to a fix and for alternative install
methods.
 [Git for
Windows]([Link] is
recommended on native Windows so Claude Code
can use the Bash tool. If Git for Windows is not
installed, Claude Code uses PowerShell as the shell
tool instead. WSL setups do not need Git for
Windows.

<Info>
Native installations automatically update in the
background to keep you on the latest version.
</Info>
</Tab>

<Tab title="Homebrew">
```bash theme={null}
brew install --cask claude-code
```

Homebrew offers two casks. `claude-code`

tracks the stable release channel, which is typically
about a week behind and skips releases with major
regressions. `claude-code@latest` tracks the latest
channel and receives new versions as soon as they
ship.

<Info>
Manuel Navarro Hidalgo.
Homebrew installations do not auto-update.
Run `brew upgrade claude-code` or `brew upgrade
claude-code@latest`, depending on which cask you
installed, to get the latest features and security
fixes.
</Info>
</Tab>

<Tab title="WinGet">
```powershell theme={null}
winget install [Link]
```

<Info>
WinGet installations do not auto-update. Run
`winget upgrade [Link]` periodically
to get the latest features and security fixes.
</Info>
</Tab>
</Tabs>

You can also install with [apt, dnf, or

apk](/en/setup#install-with-linux-package-managers)
on Debian, Fedora, RHEL, and Alpine.

Luego inicia Claude Code en cualquier proyecto:

```bash theme={null}
cd your-project
 claude
```

Se te pedirá que inicies sesión en el primer uso.

¡Eso es todo! [Continúa con la Guía de inicio rápido
→](/es/quickstart)

<Tip>
Consulta [configuración avanzada](/es/setup)
para opciones de instalación, actualizaciones
manuales o instrucciones de desinstalación. Visita
[solución de problemas de
instalación](/es/troubleshoot-install) si encuentras
problemas.
</Tip>
</Tab>

<Tab title="VS Code">

La extensión de VS Code proporciona diffs en
línea, menciones @, revisión de planes e historial de
conversación directamente en tu editor.

* [Instalar para VS
Code](vscode:extension/[Link]-code)
* [Instalar para
Cursor](cursor:extension/[Link]-code)

O busca "Claude Code" en la vista de

Extensiones (`Cmd+Shift+X` en Mac, `Ctrl+Shift+X`
Manuel Navarro Hidalgo.
en Windows/Linux). Después de instalar, abre la
Paleta de comandos (`Cmd+Shift+P` /
`Ctrl+Shift+P`), escribe "Claude Code" y selecciona
**Abrir en Nueva Pestaña**.

[Comenzar con VS Code

→](/es/vs-code#get-started)
</Tab>

<Tab title="Aplicación de escritorio">

Una aplicación independiente para ejecutar
Claude Code fuera de tu IDE o terminal. Revisa diffs
visualmente, ejecuta múltiples sesiones lado a lado,
programa tareas recurrentes e inicia sesiones en la
nube.

Descarga e instala:

*
[macOS]([Link]
sal/dmg/latest/redirect?utm_source=claude_code\&
utm_medium=docs) (Intel y Apple Silicon)
*
[Windows]([Link]
etup/latest/redirect?utm_source=claude_code\&utm
_medium=docs) (x64)
 * [Windows
ARM64]([Link]
etup/latest/redirect?utm_source=claude_code\&utm
_medium=docs)

Después de instalar, lanza Claude, inicia sesión y

haz clic en la pestaña **Code** para comenzar a
codificar. Se requiere una [suscripción de
pago]([Link]
e_code\&utm_medium=docs\&utm_content=overvie
w_desktop_pricing).

[Obtén más información sobre la aplicación de

escritorio →](/es/desktop-quickstart)
</Tab>

<Tab title="Web">
Ejecuta Claude Code en tu navegador sin
configuración local. Inicia tareas de larga duración y
vuelve cuando estén listas, trabaja en repositorios
que no tienes localmente o ejecuta múltiples tareas
en paralelo. Disponible en navegadores de
escritorio y la aplicación Claude iOS.

Comienza a codificar en
[[Link]/code]([Link]

[Comenzar en la web →](/es/web-quickstart)

</Tab>
Manuel Navarro Hidalgo.

<Tab title="JetBrains">
Un plugin para IntelliJ IDEA, PyCharm, WebStorm
y otros IDEs de JetBrains con visualización de diff
interactiva y compartición de contexto de selección.

Instala el [plugin Claude

Code]([Link]
ude-code-beta-) desde el Marketplace de JetBrains y
reinicia tu IDE. El plugin requiere la CLI de Claude
Code, instalada por separado; consulta los [pasos
de configuración de
JetBrains](/es/jetbrains#installation).

[Comenzar con JetBrains →](/es/jetbrains)

</Tab>
</Tabs>

<h2 id="what-you-can-do">
Lo que puedes hacer
</h2>

Aquí hay algunas de las formas en que puedes usar

Claude Code:

<AccordionGroup>
<Accordion title="Automatiza el trabajo que sigues
posponiendo" icon="wand-magic-sparkles">
 Claude Code maneja las tareas tediosas que
consumen tu día: escribir pruebas para código sin
probar, corregir errores de lint en un proyecto,
resolver conflictos de fusión, actualizar
dependencias y escribir notas de lanzamiento.

```bash theme={null}
claude "write tests for the auth module, run them,
and fix any failures"
```
</Accordion>

<Accordion title="Construye características y

corrige errores" icon="hammer">
Describe lo que quieres en lenguaje natural.
Claude Code planifica el enfoque, escribe el código
en múltiples archivos y verifica que funcione.

Para errores, pega un mensaje de error o describe

el síntoma. Claude Code rastrea el problema a
través de tu base de código, identifica la causa raíz
e implementa una corrección. Consulta [flujos de
trabajo comunes](/es/common-workflows) para más
ejemplos.
</Accordion>

<Accordion title="Crea commits y solicitudes de

extracción" icon="code-branch">
Manuel Navarro Hidalgo.
Claude Code funciona directamente con git.
Prepara cambios, escribe mensajes de commit, crea
ramas y abre solicitudes de extracción.

```bash theme={null}
claude "commit my changes with a descriptive
message"
```

En CI, puedes automatizar la revisión de código y

la clasificación de problemas con [GitHub
Actions](/es/github-actions) o [GitLab
CI/CD](/es/gitlab-ci-cd).
</Accordion>

<Accordion title="Conecta tus herramientas con

MCP" icon="plug">
El [Protocolo de Contexto de Modelo
(MCP)](/es/mcp) es un estándar abierto para
conectar herramientas de IA a fuentes de datos
externas. Con MCP, Claude Code puede leer tus
documentos de diseño en Google Drive, actualizar
tickets en Jira, extraer datos de Slack o usar tu
propia herramienta personalizada. El [inicio rápido
de MCP](/es/mcp-quickstart) conecta tu primer
servidor de extremo a extremo.
</Accordion>
 <Accordion title="Personaliza con instrucciones,
skills y hooks" icon="sliders">
[`[Link]`](/es/memory) es un archivo
markdown que añades a la raíz de tu proyecto que
Claude Code lee al inicio de cada sesión. Úsalo para
establecer estándares de codificación, decisiones
de arquitectura, librerías preferidas y listas de
verificación de revisión. Claude también construye
[memoria automática](/es/memory#auto-memory)
mientras trabaja, guardando aprendizajes como
comandos de compilación e insights de depuración
en sesiones sin que escribas nada.

Crea [skills](/es/skills) para empaquetar flujos de

trabajo repetibles que tu equipo pueda compartir,
como `/review-pr` o `/deploy-staging`.

[Hooks](/es/hooks) te permiten ejecutar

comandos de shell antes o después de acciones de
Claude Code, como formateo automático después
de cada edición de archivo o ejecución de lint antes
de un commit.
</Accordion>

<Accordion title="Ejecuta equipos de agentes y

construye agentes personalizados" icon="users">
Genera [múltiples agentes de Claude
Code](/es/sub-agents) que trabajen en diferentes
partes de una tarea simultáneamente. Un agente
Manuel Navarro Hidalgo.
líder coordina el trabajo, asigna subtareas y fusiona
resultados.

Para ejecutar varias sesiones completas en

paralelo y observarlas desde una pantalla, usa
[agentes en segundo plano](/es/agent-view). Para
flujos de trabajo completamente personalizados, el
[Agent SDK](/es/agent-sdk/overview) te permite
construir tus propios agentes impulsados por las
herramientas y capacidades de Claude Code, con
control total sobre orquestación, acceso a
herramientas y permisos.
</Accordion>

<Accordion title="Canaliza, secuencia y automatiza

con la CLI" icon="terminal">
Claude Code es componible y sigue la filosofía de
Unix. Canaliza registros en él, ejecútalo en CI o
encadénalo con otras herramientas:

```bash theme={null}
# Analiza la salida de registros recientes
tail -200 [Link] | claude -p "Slack me if you see
any anomalies"

# Automatiza traducciones en CI
claude -p "translate new strings into French and
raise a PR for review"
 # Operaciones en masa en archivos
git diff main --name-only | claude -p "review these
changed files for security issues"
```

Consulta la [referencia de CLI](/es/cli-reference)

para el conjunto completo de comandos y banderas.
</Accordion>

<Accordion title="Programa tareas recurrentes"

icon="clock">
Ejecuta Claude en un horario para automatizar el
trabajo que se repite: revisiones de PR matutinas,
análisis de fallos de CI durante la noche, auditorías
de dependencias semanales o sincronización de
documentos después de que se fusionen los PR.

* [Routines](/es/routines) se ejecutan en
infraestructura administrada por Anthropic, por lo
que siguen ejecutándose incluso cuando tu
computadora está apagada. También pueden
activarse en llamadas de API o eventos de GitHub.
Créalas desde la web, la aplicación de escritorio o
ejecutando `/schedule` en la CLI.
* [Tareas programadas de
escritorio](/es/desktop-scheduled-tasks) se ejecutan
en tu máquina, con acceso directo a tus archivos y
herramientas locales
Manuel Navarro Hidalgo.
* [`/loop`](/es/scheduled-tasks) repite un prompt
dentro de una sesión de CLI para sondeo rápido
</Accordion>

<Accordion title="Trabaja desde cualquier lugar"

icon="globe">
Las sesiones no están vinculadas a una única
superficie. Mueve el trabajo entre entornos a medida
que cambia tu contexto:

* Aléjate de tu escritorio y sigue trabajando desde

tu teléfono o cualquier navegador con [Remote
Control](/es/remote-control)
* Envía un mensaje a
[Dispatch](/es/desktop#sessions-from-dispatch) con
una tarea desde tu teléfono y abre la sesión de
escritorio que crea
* Inicia una tarea de larga duración en la
[web](/es/claude-code-on-the-web) o [aplicación
iOS]([Link]
c/id6473753684), luego extráela a tu terminal con
`claude --teleport`. Teleport requiere una suscripción
a [Link].
* Transfiere una sesión de terminal a la
[aplicación de escritorio](/es/desktop) con
`/desktop` para revisión visual de diff
* Enruta tareas desde el chat del equipo:
menciona `@Claude` en [Slack](/es/slack) con un
informe de error y obtén una solicitud de extracción
de vuelta
</Accordion>
</AccordionGroup>

<h2 id="use-claude-code-everywhere">
Usa Claude Code en todas partes
</h2>

Cada superficie se conecta al mismo motor

subyacente de Claude Code, por lo que tus archivos
[Link], configuración y servidores MCP
funcionan en todos ellos.

Más allá de los entornos [Terminal](/es/quickstart),

[VS Code](/es/vs-code), [JetBrains](/es/jetbrains),
[Desktop](/es/desktop) y
[Web](/es/claude-code-on-the-web) anteriores,
Claude Code se integra con flujos de trabajo de
CI/CD, chat y navegador:

| Quiero...
| Mejor opción
|
|
---------------------------------------------------------------------------
--------- |
---------------------------------------------------------------------------
--------------------------------------------- |
Manuel Navarro Hidalgo.
| Continuar una sesión local desde mi teléfono u
otro dispositivo | [Remote
Control](/es/remote-control)
|
| Enviar eventos desde Telegram, Discord, iMessage
o mis propios webhooks a una sesión |
[Channels](/es/channels)
|
| Iniciar una tarea localmente, continuar en móvil
| [Web](/es/claude-code-on-the-web) o [aplicación
Claude
iOS]([Link]
c/id6473753684) |
| Ejecutar Claude en un horario recurrente
| [Routines](/es/routines) o [Tareas programadas de
escritorio](/es/desktop-scheduled-tasks)
|
| Automatizar revisiones de PR y clasificación de
problemas | [GitHub
Actions](/es/github-actions) o [GitLab
CI/CD](/es/gitlab-ci-cd) |
| Obtener revisión de código automática en cada PR
| [GitHub Code Review](/es/code-review)
|
| Enrutar informes de errores de Slack a solicitudes
de extracción | [Slack](/es/slack)
|
| Depurar aplicaciones web en vivo
| [Chrome](/es/chrome)
|
| Construir agentes personalizados para tus propios
flujos de trabajo | [Agent
SDK](/es/agent-sdk/overview)
|

<h2 id="next-steps">
Próximos pasos
</h2>

Una vez que hayas instalado Claude Code, estas

guías te ayudan a profundizar.

* [Guía de inicio rápido](/es/quickstart): recorre tu

primera tarea real, desde explorar una base de
código hasta confirmar una corrección
* [Almacena instrucciones y
memorias](/es/memory): proporciona a Claude
instrucciones persistentes con archivos
[Link] y memoria automática
* [Flujos de trabajo
comunes](/es/common-workflows) y [mejores
prácticas](/es/best-practices): patrones para obtener
lo máximo de Claude Code
* [Configuración](/es/settings): personaliza Claude
Code para tu flujo de trabajo
Manuel Navarro Hidalgo.
* [Solución de problemas](/es/troubleshooting):
soluciones para problemas comunes
* [[Link]]([Link]
demostraciones, precios y detalles del producto.

Inicio rápido

¡Bienvenido a Claude Code!

Esta guía de inicio rápido le permitirá usar

asistencia de codificación impulsada por IA en
pocos minutos. Al final, comprenderá cómo usar
Claude Code para tareas comunes de desarrollo.

<h2 id="before-you-begin">
Antes de comenzar
</h2>
Asegúrese de tener:

* Una terminal o símbolo del sistema abiertos

* Si nunca ha usado la terminal antes, consulte la
[guía de terminal](/es/terminal-guide)
* Un proyecto de código con el que trabajar
* Una [suscripción a
Claude]([Link]
ude_code\&utm_medium=docs\&utm_content=quick
start_prereq) (Pro, Max, Team o Enterprise), una
cuenta de [Claude
Console]([Link] o acceso
a través de un [proveedor de nube
compatible](/es/third-party-integrations)

<Note>
Esta guía cubre la CLI de terminal. Claude Code
también está disponible en la
[web]([Link] como una [aplicación
de escritorio](/es/desktop), en [VS
Code](/es/vs-code) e [IDEs de
JetBrains](/es/jetbrains), en [Slack](/es/slack), y en
CI/CD con [GitHub Actions](/es/github-actions) y
[GitLab](/es/gitlab-ci-cd). Consulte [todas las
interfaces](/es/overview#use-claude-code-everywher
e).
</Note>
Manuel Navarro Hidalgo.
<h2 id="step-1-install-claude-code">
Paso 1: Instalar Claude Code
</h2>

To install Claude Code, use one of the following

methods:

<Tabs>
<Tab title="Native Install (Recommended)">
**macOS, Linux, WSL:**

```bash theme={null}
curl -fsSL [Link] | bash
```

**Windows PowerShell:**

```powershell theme={null}
irm [Link] | iex
```

**Windows CMD:**

```batch theme={null}
curl -fsSL [Link] -o
[Link] && [Link] && del [Link]
```
 If you see `The token '&&' is not a valid statement
separator`, you're in PowerShell, not CMD. If you
see `'irm' is not recognized as an internal or external
command`, you're in CMD, not PowerShell. Your
prompt shows `PS C:\` when you're in PowerShell
and `C:\` without the `PS` when you're in CMD.

If the install command fails with `syntax error near

unexpected token '<'`, a `403`, or another curl error,
see [Troubleshoot
installation](/en/troubleshoot-install#find-your-error)
to match the error to a fix and for alternative install
methods.

[Git for
Windows]([Link] is
recommended on native Windows so Claude Code
can use the Bash tool. If Git for Windows is not
installed, Claude Code uses PowerShell as the shell
tool instead. WSL setups do not need Git for
Windows.

<Info>
Native installations automatically update in the
background to keep you on the latest version.
</Info>
</Tab>

<Tab title="Homebrew">
Manuel Navarro Hidalgo.
```bash theme={null}
brew install --cask claude-code
```

Homebrew offers two casks. `claude-code` tracks

the stable release channel, which is typically about a
week behind and skips releases with major
regressions. `claude-code@latest` tracks the latest
channel and receives new versions as soon as they
ship.

<Info>
Homebrew installations do not auto-update. Run
`brew upgrade claude-code` or `brew upgrade
claude-code@latest`, depending on which cask you
installed, to get the latest features and security
fixes.
</Info>
</Tab>

<Tab title="WinGet">
```powershell theme={null}
winget install [Link]
```

<Info>
WinGet installations do not auto-update. Run
`winget upgrade [Link]` periodically
to get the latest features and security fixes.
 </Info>
</Tab>
</Tabs>

You can also install with [apt, dnf, or

apk](/en/setup#install-with-linux-package-managers)
on Debian, Fedora, RHEL, and Alpine.

<h2 id="step-2-log-in-to-your-account">
Paso 2: Inicie sesión en su cuenta
</h2>

Claude Code requiere una cuenta para usarse. Inicie

una sesión interactiva con el comando `claude` y se
le pedirá que inicie sesión en el primer uso:

```bash theme={null}
claude
```

Para cuentas de suscripción de Claude o Console,

siga las indicaciones para completar la
autenticación en su navegador. Para cambiar de
cuenta más tarde o volver a autenticarse, escriba
`/login` dentro de la sesión en ejecución:

```text theme={null}
/login
```
Manuel Navarro Hidalgo.

Puede iniciar sesión usando cualquiera de estos

tipos de cuenta:

* [Claude Pro, Max, Team o

Enterprise]([Link]
claude_code\&utm_medium=docs\&utm_content=qu
ickstart_login) (recomendado)
* [Claude Console]([Link]
(acceso a API con créditos prepagados). En el
primer inicio de sesión, se crea automáticamente un
espacio de trabajo "Claude Code" en la Console
para el seguimiento centralizado de costos.
* [Amazon Bedrock, Google Vertex AI o Microsoft
Foundry](/es/third-party-integrations) (proveedores
de nube empresariales)
* Una puerta de enlace [Claude apps
gateway](/es/claude-apps-gateway) auto hospedada,
si su organización ejecuta una: su administrador
preconfiguración la URL de la puerta de enlace, y
`/login` abre directamente en la pantalla **Cloud
gateway** para que inicie sesión con SSO
corporativo

Una vez que haya iniciado sesión, sus credenciales

se almacenan y no necesitará iniciar sesión
nuevamente.

<h2 id="step-3-start-your-first-session">
 Paso 3: Inicie su primera sesión
</h2>

Abra su terminal en cualquier directorio de proyecto

e inicie Claude Code:

```bash theme={null}
cd /path/to/your/project
claude
```

Verá la pantalla de Claude Code con la versión, el

modelo actual y el directorio de trabajo mostrados
arriba. Escriba `/help` para ver los comandos
disponibles o `/resume` para continuar una
conversación anterior.

<Tip>
Después de iniciar sesión (Paso 2), sus
credenciales se almacenan en su sistema. Obtenga
más información en [Gestión de
credenciales](/es/authentication#credential-manage
ment).
</Tip>

<h2 id="step-4-ask-your-first-question">
Paso 4: Haga su primera pregunta
</h2>
Manuel Navarro Hidalgo.
Comencemos por entender su base de código.
Intente uno de estos comandos:

```text theme={null}
¿qué hace este proyecto?
```

Claude analizará sus archivos y proporcionará un

resumen. También puede hacer preguntas más
específicas:

```text theme={null}
¿qué tecnologías usa este proyecto?
```

```text theme={null}
¿dónde está el punto de entrada principal?
```

```text theme={null}
explique la estructura de carpetas
```

También puede preguntarle a Claude sobre sus

propias capacidades:

```text theme={null}
¿qué puede hacer Claude Code?
```
```text theme={null}
¿cómo creo skills personalizados en Claude Code?
```

```text theme={null}
¿puede Claude Code trabajar con Docker?
```

<Note>
Claude Code lee los archivos de su proyecto según
sea necesario. No tiene que agregar contexto
manualmente.
</Note>

<h2 id="step-5-make-your-first-code-change">
Paso 5: Realice su primer cambio de código
</h2>

Ahora hagamos que Claude Code haga algo de

codificación real. Intente una tarea simple:

```text theme={null}
agrega una función hello world al archivo principal
```

Claude Code hará lo siguiente:

1. Encontrará el archivo apropiado

Manuel Navarro Hidalgo.
2. Le mostrará los cambios propuestos
3. Le pedirá su aprobación
4. Realizará la edición

<Note>
Claude Code siempre pide permiso antes de
modificar archivos. Puede aprobar cambios
individuales o habilitar el modo "Aceptar todo" para
una sesión.
</Note>

<h2 id="step-6-use-git-with-claude-code">
Paso 6: Use Git con Claude Code
</h2>

Claude Code hace que las operaciones de Git sean

conversacionales:

```text theme={null}
¿qué archivos he cambiado?
```

```text theme={null}
confirma mis cambios con un mensaje descriptivo
```

También puede solicitar operaciones de Git más

complejas:
```text theme={null}
crea una nueva rama llamada feature/quickstart
```

```text theme={null}
muéstrame los últimos 5 commits
```

```text theme={null}
ayúdame a resolver conflictos de fusión
```

<h2 id="step-7-fix-a-bug-or-add-a-feature">
Paso 7: Corrija un error o agregue una función
</h2>

Claude es competente en depuración e

implementación de funciones.

Describa lo que desea en lenguaje natural:

```text theme={null}
agrega validación de entrada al formulario de
registro de usuarios
```

O corrija problemas existentes:

```text theme={null}
Manuel Navarro Hidalgo.
hay un error donde los usuarios pueden enviar
formularios vacíos - corrígelo
```

Claude Code hará lo siguiente:

* Localizará el código relevante

* Comprenderá el contexto
* Implementará una solución
* Ejecutará pruebas si están disponibles

<h2 id="step-8-test-out-other-common-workflows">
Paso 8: Pruebe otros flujos de trabajo comunes
</h2>

Hay varias formas de trabajar con Claude:

**Refactorizar código**

```text theme={null}
refactoriza el módulo de autenticación para usar
async/await en lugar de callbacks
```

**Escribir pruebas**

```text theme={null}
escribe pruebas unitarias para las funciones de
calculadora
```

**Actualizar documentación**

```text theme={null}
actualiza el README con instrucciones de
instalación
```

**Revisión de código**

```text theme={null}
revisa mis cambios y sugiere mejoras
```

<Tip>
Hable con Claude como lo haría con un colega útil.
Describa lo que desea lograr y le ayudará a llegar
allí.
</Tip>

<h2 id="essential-commands">
Comandos esenciales
</h2>

Aquí están los comandos más importantes para el

uso diario. Los comandos de shell se ejecutan
desde su terminal para iniciar o reanudar Claude
Manuel Navarro Hidalgo.
Code. Los comandos de sesión se ejecutan dentro
de Claude Code después de que se inicia.

**Comandos de shell**

| Comando | Qué hace

| Ejemplo |
| ------------------- |
------------------------------------------------------------- |
----------------------------------- |
| `claude` | Inicia el modo interactivo
| `claude` |
| `claude "task"` | Ejecuta una tarea única
| `claude "fix the build error"` |
| `claude -p "query"` | Ejecuta una consulta única y
luego sale | `claude -p "explain this
function"` |
| `claude -c` | Continúa la conversación más
reciente en el directorio actual | `claude -c`
|
| `claude -r` | Reanuda una conversación
anterior | `claude -r` |

**Comandos de sesión**

| Comando | Qué hace | Ejemplo

|
| ---------------- | ---------------------------------- | -------- |
| `/clear` | Borra el historial de conversación |
`/clear` |
| `/help` | Muestra los comandos disponibles |
`/help` |
| `/exit` o Ctrl+D | Salir de Claude Code |
`/exit` |

Consulte la [referencia de CLI](/es/cli-reference)

para obtener una lista completa de comandos de
shell y la [referencia de comandos](/es/commands)
para obtener una lista completa de comandos de
sesión.

<h2 id="pro-tips-for-beginners">
Consejos profesionales para principiantes
</h2>

Para más información, consulte [mejores

prácticas](/es/best-practices) y [flujos de trabajo
comunes](/es/common-workflows).

<AccordionGroup>
<Accordion title="Sea específico con sus
solicitudes">
En lugar de: "corrige el error"

Intente: "corrige el error de inicio de sesión

donde los usuarios ven una pantalla en blanco
después de ingresar credenciales incorrectas"
Manuel Navarro Hidalgo.
</Accordion>

<Accordion title="Utilice instrucciones paso a

paso">
Divida tareas complejas en pasos:

```text theme={null}
1. crea una nueva tabla de base de datos para
perfiles de usuario
2. crea un endpoint de API para obtener y
actualizar perfiles de usuario
3. construye una página web que permita a los
usuarios ver y editar su información
```
</Accordion>

<Accordion title="Deje que Claude explore

primero">
Antes de hacer cambios, deje que Claude
entienda su código:

```text theme={null}
analiza el esquema de la base de datos
```

```text theme={null}
construye un panel que muestre los productos
que nuestros clientes del Reino Unido devuelven
con más frecuencia
 ```
</Accordion>

<Accordion title="Ahorre tiempo con atajos de

teclado">
* Escriba `/` para ver todos los comandos y skills
* Utilice Tab para completar comandos
* Presione ↑ para el historial de comandos
* Presione `Shift+Tab` para ciclar a través de los
modos de permisos
</Accordion>
</AccordionGroup>

<h2 id="what’s-next">
¿Qué sigue?
</h2>

Ahora que ha aprendido lo básico, explore

funciones más avanzadas:

<CardGroup cols={2}>
<Card title="Cómo funciona Claude Code"
icon="microchip"
href="/es/how-claude-code-works">
Comprenda el bucle de agente, las herramientas
integradas y cómo Claude Code interactúa con su
proyecto
</Card>
Manuel Navarro Hidalgo.
<Card title="Mejores prácticas" icon="star"
href="/es/best-practices">
Obtenga mejores resultados con indicaciones
efectivas y configuración de proyecto
</Card>

<Card title="Flujos de trabajo comunes"

icon="graduation-cap"
href="/es/common-workflows">
Guías paso a paso para tareas comunes
</Card>

<Card title="Extiende Claude Code"

icon="puzzle-piece" href="/es/features-overview">
Personalice con [Link], skills, hooks, MCP
y más
</Card>
</CardGroup>

<h2 id="getting-help">
Obtener ayuda
</h2>

* **En Claude Code**: Escriba `/help` o pregunte

"¿cómo..."
* **Documentación**: ¡Está aquí! Explore otras guías
* **Comunidad**: Únase a nuestro
[Discord]([Link] para
consejos y soporte
Registro de cambios [Link]

●​ Presentamos Claude Sonnet 5: ahora el modelo

predeterminado en Claude Code, con una
ventana de contexto nativa de 1 millón de
tokens y precios promocionales de $2/$10 por
Mtok hasta el 31 de agosto. Actualice a la
versión 2.1.197 para acceder.
[Link]
5

👇
[Link]
n/[Link]
Manuel Navarro Hidalgo.

Cómo funciona Claude Code

> Comprenda el bucle agentico, las herramientas

integradas y cómo Claude Code interactúa con su
proyecto.

Claude Code es un asistente agentico que se

ejecuta en su terminal. Aunque destaca en
codificación, puede ayudarle con cualquier cosa
que pueda hacer desde la línea de comandos:
escribir documentación, ejecutar compilaciones,
buscar archivos, investigar temas y más.

Esta guía cubre la arquitectura principal, las

capacidades integradas y [consejos para trabajar
efectivamente](#work-effectively-with-claude-code).
Para tutoriales paso a paso, consulte [Flujos de
trabajo comunes](/es/common-workflows). Para
características de extensibilidad como skills, MCP y
hooks, consulte [Extender Claude
Code](/es/features-overview).

<h2 id="the-agentic-loop">
El bucle agentico
</h2>

Cuando le da una tarea a Claude, trabaja a través de

tres fases: **recopilar contexto**, **tomar acción** y
**verificar resultados**. Estas fases se mezclan
entre sí. Claude utiliza herramientas en todo
momento, ya sea buscando archivos para entender
su código, editando para hacer cambios o
ejecutando pruebas para verificar su trabajo.

<img
src="[Link]
ahteV/images/[Link]?fit=max&auto=forma
Manuel Navarro Hidalgo.
t&n=ikqp3_70mqIahteV&q=85&s=4a30fb7ce2815012
a9f27c955e2c6bb0" alt="Diagrama del bucle
agentico: Su indicación lleva a Claude a recopilar
contexto, tomar acción, verificar resultados y repetir
hasta completar la tarea. Puede interrumpir en
cualquier momento." width="720" height="280"
data-path="images/[Link]" />

El bucle se adapta a lo que pregunta. Una pregunta

sobre su base de código podría necesitar solo
recopilación de contexto. Una corrección de errores
cicla a través de las tres fases repetidamente. Una
refactorización podría implicar una verificación
extensa. Claude decide qué requiere cada paso
basándose en lo que aprendió del paso anterior,
encadenando docenas de acciones juntas y
corrigiendo el curso en el camino.

Usted también es parte de este bucle. Puede

interrumpir en cualquier momento para dirigir a
Claude en una dirección diferente, proporcionar
contexto adicional o pedirle que intente un enfoque
diferente. Claude trabaja de forma autónoma pero
permanece receptivo a su entrada.

El bucle agentico está impulsado por dos

componentes: [modelos](#models) que razonan y
[herramientas](#tools) que actúan. Claude Code
sirve como el **arnés agentico** alrededor de
Claude: proporciona las herramientas, la gestión del
contexto y el entorno de ejecución que convierten
un modelo de lenguaje en un agente de codificación
capaz.

<h3 id="models">
Modelos
</h3>

Claude Code utiliza modelos Claude para entender

su código y razonar sobre tareas. Claude puede leer
código en cualquier idioma, entender cómo se
conectan los componentes y determinar qué
necesita cambiar para lograr su objetivo. Para
tareas complejas, divide el trabajo en pasos, los
ejecuta y se ajusta basándose en lo que aprende.

[Múltiples modelos](/es/model-config) están

disponibles con diferentes compensaciones. Sonnet
maneja bien la mayoría de tareas de codificación.
Opus proporciona un razonamiento más fuerte para
decisiones arquitectónicas complejas. Cambie con
`/model` durante una sesión o comience con `claude
--model <name>`.

Cuando esta guía dice "Claude elige" o "Claude

decide", es el modelo el que está haciendo el
razonamiento.
Manuel Navarro Hidalgo.
<h3 id="tools">
Herramientas
</h3>

Las herramientas son lo que hace que Claude Code

sea agentico. Sin herramientas, Claude solo puede
responder con texto. Con herramientas, Claude
puede actuar: leer su código, editar archivos,
ejecutar comandos, buscar en la web e interactuar
con servicios externos. Cada uso de herramienta
devuelve información que se retroalimenta en el
bucle, informando la siguiente decisión de Claude.

Las herramientas integradas generalmente se

dividen en cinco categorías, cada una
representando un tipo diferente de agencia.

| Categoría | Lo que Claude puede hacer

|
| -------------------------- |
---------------------------------------------------------------------------
---------------------------------------------------------------------------
-------------------------------------- |
| **Operaciones de archivo** | Leer archivos, editar
código, crear nuevos archivos, renombrar y
reorganizar
|
| **Búsqueda** | Encontrar archivos por
patrón, buscar contenido con regex, explorar bases
de código
|
| **Ejecución** | Ejecutar comandos de shell,
iniciar servidores, ejecutar pruebas, usar git
|
| **Web** | Buscar en la web, obtener
documentación, buscar mensajes de error
|
| **Inteligencia de código** | Ver errores de tipo y
advertencias después de ediciones, saltar a
definiciones, encontrar referencias (requiere
[plugins de inteligencia de
código](/es/discover-plugins#code-intelligence)) |

Estas son las capacidades principales. Claude

también tiene herramientas para generar subagents,
hacerle preguntas y otras tareas de orquestación.
Consulte [Herramientas disponibles para
Claude](/es/tools-reference) para la lista completa.

Claude elige qué herramientas usar basándose en

su indicación y lo que aprende en el camino.
Cuando dice "arreglar las pruebas fallidas", Claude
podría:

1. Ejecutar el conjunto de pruebas para ver qué está

fallando
2. Leer la salida de error
3. Buscar los archivos de código fuente relevantes
Manuel Navarro Hidalgo.
4. Leer esos archivos para entender el código
5. Editar los archivos para arreglar el problema
6. Ejecutar las pruebas nuevamente para verificar

Cada uso de herramienta le da a Claude nueva

información que informa el siguiente paso. Este es
el bucle agentico en acción.

**Extender las capacidades base:** Las

herramientas integradas son la base. Puede
extender lo que Claude sabe con [skills](/es/skills),
conectarse a servicios externos con [MCP](/es/mcp),
automatizar flujos de trabajo con [hooks](/es/hooks)
y delegar tareas a [subagents](/es/sub-agents).
Estas extensiones forman una capa encima del
bucle agentico principal. Consulte [Extender Claude
Code](/es/features-overview) para orientación sobre
cómo elegir la extensión correcta para sus
necesidades.

<h2 id="what-claude-can-access">
A qué puede acceder Claude
</h2>

Esta guía se enfoca en la terminal. Claude Code

también se ejecuta en [VS Code](/es/vs-code), [IDEs
de JetBrains](/es/jetbrains) y otros entornos.
Cuando ejecuta `claude` en un directorio, Claude
Code obtiene acceso a:

* **Su proyecto.** Archivos en su directorio y

subdirectorios, más archivos en otros lugares con
su permiso.
* **Su terminal.** Cualquier comando que pueda
ejecutar: herramientas de compilación, git, gestores
de paquetes, utilidades del sistema, scripts. Si
puede hacerlo desde la línea de comandos, Claude
también puede.
* **Su estado de git.** Rama actual, cambios sin
confirmar e historial de confirmaciones recientes.
* **Su [[Link]](/es/memory).** Un archivo
markdown donde almacena instrucciones
específicas del proyecto, convenciones y contexto
que Claude debe conocer en cada sesión.
* **[Auto memory](/es/memory#auto-memory).**
Aprendizajes que Claude guarda automáticamente
mientras trabaja, como patrones de proyecto y sus
preferencias. Las primeras 200 líneas o 25KB de
[Link], lo que sea menor, se cargan al inicio
de cada sesión.
* **Extensiones que configure.** [Servidores
MCP](/es/mcp) para servicios externos,
[skills](/es/skills) para flujos de trabajo,
[subagents](/es/sub-agents) para trabajo delegado y
[Claude en Chrome](/es/chrome) para interacción
del navegador.
Manuel Navarro Hidalgo.

Debido a que Claude ve todo su proyecto, puede

trabajar en él. Cuando le pide a Claude que "arregle
el error de autenticación", busca archivos
relevantes, lee múltiples archivos para entender el
contexto, realiza ediciones coordinadas en ellos,
ejecuta pruebas para verificar la corrección y
confirma los cambios si lo solicita. Esto es diferente
de los asistentes de código en línea que solo ven el
archivo actual.

<h2 id="environments-and-interfaces">
Entornos e interfaces
</h2>

El bucle agentico, las herramientas y las

capacidades descritas anteriormente son iguales en
todas partes donde use Claude Code. Lo que
cambia es dónde se ejecuta el código y cómo
interactúa con él.

<h3 id="execution-environments">
Entornos de ejecución
</h3>

Claude Code se ejecuta en tres entornos, cada uno

con diferentes compensaciones para dónde se
ejecuta su código.
| Entorno | Dónde se ejecuta el código
| Caso de uso |
| ------------------ | ----------------------------------------- |
---------------------------------------------------------------------- |
| **Local** | Su máquina |
Predeterminado. Acceso completo a sus archivos,
herramientas y entorno |
| **Cloud** | VMs administradas por Anthropic
| Delegar tareas, trabajar en repositorios que no
tiene localmente |
| **Control remoto** | Su máquina, controlada desde
un navegador | Usar la interfaz web mientras
mantiene todo local |

<h3 id="interfaces">
Interfaces
</h3>

Puede acceder a Claude Code a través de la

terminal, la [aplicación de escritorio](/es/desktop),
[extensiones de IDE](/es/vs-code),
[[Link]/code]([Link] [Control
remoto](/es/remote-control), [Slack](/es/slack) y
[canalizaciones CI/CD](/es/github-actions). La
interfaz determina cómo ve e interactúa con Claude,
pero el bucle agentico subyacente es idéntico.
Consulte [Usar Claude Code en todas
partes](/es/overview#use-claude-code-everywhere)
para la lista completa.
Manuel Navarro Hidalgo.

<h2 id="work-with-sessions">
Trabajar con sesiones
</h2>

Claude Code guarda su conversación localmente

mientras trabaja. Cada mensaje, uso de herramienta
y resultado se escribe en un archivo JSONL de texto
plano bajo `~/.claude/projects/`, lo que permite
[rebobinar](#undo-changes-with-checkpoints),
[reanudar y bifurcar](#resume-or-fork-sessions)
sesiones. Antes de que Claude realice cambios de
código, también toma una instantánea de los
archivos afectados para que pueda revertir si es
necesario. Para rutas, retención y cómo borrar estos
datos, consulte [datos de aplicación en
`~/.claude`](/es/claude-directory#application-data).

**Las sesiones son independientes.** Cada nueva

sesión comienza con una ventana de contexto
nueva, sin el historial de conversación de sesiones
anteriores. Claude puede persistir aprendizajes
entre sesiones usando [auto
memory](/es/memory#auto-memory), y puede
agregar sus propias instrucciones persistentes en
[[Link]](/es/memory).

<h3 id="work-across-branches">
Trabajar entre ramas
</h3>

Cada conversación de Claude Code es una sesión

vinculada a su directorio actual. El selector
`/resume` muestra sesiones del worktree actual de
forma predeterminada, con atajos de teclado para
ampliar la lista a otros worktrees o proyectos.
Consulte [Gestionar
sesiones](/es/sessions#use-the-session-picker) para
la lista completa de atajos de teclado del selector y
cómo funciona la resolución de nombres.

Claude ve los archivos de su rama actual. Cuando

cambia de rama, Claude ve los archivos de la nueva
rama, pero el historial de conversación permanece
igual. Claude recuerda lo que discutió incluso
después de cambiar de rama.

Dado que las sesiones están vinculadas a

directorios, puede ejecutar sesiones paralelas de
Claude Code usando [git worktrees](/es/worktrees),
que crean directorios separados para ramas
individuales.

<h3 id="resume-or-fork-sessions">
Reanudar o bifurcar sesiones
</h3>
Manuel Navarro Hidalgo.
Reanudar una sesión con `claude --continue` o
`claude --resume` la reabre bajo el mismo ID de
sesión y agrega nuevos mensajes a la conversación
existente. Bifurcar con `--fork-session` o `/branch`
copia el historial en un nuevo ID de sesión, dejando
el original sin cambios.

<img
src="[Link]
ahteV/images/[Link]?fit=max&auto=
format&n=ikqp3_70mqIahteV&q=85&s=04ed0984a58
e4127e05b3640265241a3" alt="Continuidad de
sesión: reanudar continúa la misma sesión, bifurcar
crea una nueva rama con un nuevo ID." width="560"
height="280"
data-path="images/[Link]" />

Para las banderas de reanudación, el selector

`/resume`, nombres y qué sucede cuando la misma
sesión está abierta en dos terminales, consulte
[Gestionar sesiones](/es/sessions).

<h3 id="the-context-window">
La ventana de contexto
</h3>

La ventana de contexto de Claude contiene el

historial de su conversación, contenidos de
archivos, salidas de comandos,
[[Link]](/es/memory), [auto
memory](/es/memory#auto-memory), skills cargadas
e instrucciones del sistema. A medida que trabaja,
el contexto se llena. Claude se compacta
automáticamente, pero las instrucciones del
principio de la conversación pueden perderse.
Coloque reglas persistentes en [Link] y
ejecute `/context` para ver qué está usando espacio.

Para un recorrido interactivo de qué se carga y

cuándo, consulte [Explorar la ventana de
contexto](/es/context-window).

<h4 id="when-context-fills-up">
Cuando el contexto se llena
</h4>

Claude Code gestiona el contexto automáticamente

a medida que se acerca al límite. Primero borra
salidas de herramientas más antiguas, luego
resume la conversación si es necesario. Sus
solicitudes y fragmentos de código clave se
preservan; las instrucciones detalladas del principio
de la conversación pueden perderse. Coloque
reglas persistentes en [Link] en lugar de
depender del historial de conversación.

Para controlar qué se preserva durante la

compactación, agregue una sección "Compact
Manuel Navarro Hidalgo.
Instructions" a [Link] o ejecute `/compact`
con un enfoque (como `/compact focus on the API
changes`).

Si un archivo único o salida de herramienta es tan

grande que el contexto se vuelve a llenar
inmediatamente después de cada resumen, Claude
Code deja de compactarse automáticamente
después de algunos intentos y muestra un error en
lugar de hacer un bucle. Consulte [Auto-compaction
stops with a thrashing
error](/es/troubleshooting#auto-compaction-stops-w
ith-a-thrashing-error) para pasos de recuperación.

Ejecute `/context` para ver qué está usando espacio.

Las definiciones de herramientas MCP se difieren
por defecto y se cargan bajo demanda a través de
[búsqueda de
herramientas](/es/mcp#scale-with-mcp-tool-search),
por lo que solo los nombres de herramientas
consumen contexto hasta que Claude use una
herramienta específica. Ejecute `/mcp` para verificar
costos por servidor.

<h4
id="manage-context-with-skills-and-subagents">
Gestionar contexto con skills y subagents
</h4>
Más allá de la compactación, puede usar otras
características para controlar qué se carga en el
contexto.

[Skills](/es/skills) se cargan bajo demanda. Claude

ve descripciones de skills al inicio de la sesión, pero
el contenido completo solo se carga cuando se usa
una skill. Para skills que invoca manualmente,
establezca `disable-model-invocation: true` para
mantener descripciones fuera del contexto hasta
que las necesite. Para skills que no escribió, use
[`skillOverrides`](/es/skills#override-skill-visibility-fr
om-settings) para hacer lo mismo desde la
configuración.

[Subagents](/es/sub-agents) obtienen su propio

contexto nuevo, completamente separado de su
conversación principal. Su trabajo no infla su
contexto. Cuando terminan, devuelven un resumen.
Este aislamiento es por qué los subagents ayudan
con sesiones largas.

Consulte [costos de
contexto](/es/features-overview#understand-context
-costs) para lo que cuesta cada característica y
[reducir el uso de
tokens](/es/costs#reduce-token-usage) para
consejos sobre cómo gestionar el contexto.
Manuel Navarro Hidalgo.
<h2
id="stay-safe-with-checkpoints-and-permissions">
Manténgase seguro con checkpoints y permisos
</h2>

Claude tiene dos mecanismos de seguridad: los

checkpoints le permiten deshacer cambios de
archivo y los permisos controlan qué puede hacer
Claude sin preguntar.

<h3 id="undo-changes-with-checkpoints">
Deshacer cambios con checkpoints
</h3>

**Cada edición de archivo es reversible.** Antes de

que Claude edite cualquier archivo, toma una
instantánea del contenido actual. Si algo sale mal,
presione `Esc` dos veces para rebobinar a un
estado anterior, o pida a Claude que deshaga.

Los checkpoints son locales a su sesión, separados

de git. Solo cubren cambios de archivo. Las
acciones que afectan sistemas remotos (bases de
datos, APIs, implementaciones) no pueden ser
checkpointed, por lo que Claude pregunta antes de
ejecutar comandos con efectos secundarios
externos.

<h3 id="control-what-claude-can-do">
 Controle qué puede hacer Claude
</h3>

Presione `Shift+Tab` para ciclar a través de modos

de permiso:

* **Predeterminado**: Claude pregunta antes de

ediciones de archivo y comandos de shell
* **Auto-aceptar ediciones**: Claude edita archivos y
ejecuta comandos comunes del sistema de archivos
como `mkdir` y `mv` sin preguntar, aún pregunta por
otros comandos
* **Plan Mode**: Claude explora y propone un plan
sin editar sus archivos fuente; los avisos de
permiso aún se aplican como en el modo
predeterminado
* **Auto mode**: Claude evalúa todas las acciones
con verificaciones de seguridad en segundo plano.
Actualmente una vista previa de investigación

También puede permitir comandos específicos en

`.claude/[Link]` para que Claude no pregunte
cada vez. Esto es útil para comandos confiables
como `npm test` o `git status`. La configuración
puede tener alcance desde políticas de toda la
organización hasta preferencias personales.
Consulte [Permisos](/es/permissions) para detalles.

***
Manuel Navarro Hidalgo.

<h2 id="work-effectively-with-claude-code">
Trabajar efectivamente con Claude Code
</h2>

Estos consejos le ayudan a obtener mejores

resultados de Claude Code.

<h3 id="ask-claude-code-for-help">
Pida ayuda a Claude Code
</h3>

Claude Code puede enseñarle cómo usarlo. Haga

preguntas como "¿cómo configuro hooks?" o
"¿cuál es la mejor manera de estructurar mi
[Link]?" y Claude explicará.

Los comandos integrados también lo guían a través

de la configuración:

* `/init` lo guía a través de la creación de un

[Link] para su proyecto
* `/agents` lo ayuda a configurar subagents
personalizados
* `/doctor` diagnostica problemas comunes con su
instalación

<h3 id="it’s-a-conversation">
Es una conversación
</h3>

Claude Code es conversacional. No necesita

indicaciones perfectas. Comience con lo que desea,
luego refine:

```text theme={null}
Arreglar el error de inicio de sesión
```

\[Claude investiga, intenta algo]

```text theme={null}
Eso no es del todo correcto. El problema está en el
manejo de sesiones.
```

\[Claude ajusta el enfoque]

Cuando el primer intento no es correcto, no

comienza de nuevo. Itera.

<h4 id="interrupt-and-steer">
Interrumpir y dirigir
</h4>

Puede redirigir a Claude en cualquier momento sin

esperar a que termine el turno o comenzar de
nuevo:
Manuel Navarro Hidalgo.

* **Presione `Esc`** para detener a Claude

inmediatamente. La llamada de herramienta en
ejecución se cancela y Claude espera su siguiente
instrucción.
* **Escriba una corrección y presione `Enter`** para
enviarla sin detener la herramienta en ejecución.
Claude la lee tan pronto como se completa la acción
actual y se ajusta antes de decidir su siguiente
paso.

<h3 id="be-specific-upfront">
Sea específico desde el principio
</h3>

Cuanto más precisa sea su indicación inicial, menos

correcciones necesitará. Haga referencia a archivos
específicos, mencione restricciones y señale
patrones de ejemplo.

```text theme={null}
El flujo de pago está roto para usuarios con tarjetas
vencidas.
Verifique src/payments/ para el problema,
especialmente la actualización de tokens.
Escriba una prueba fallida primero, luego arréglela.
```
Las indicaciones vagas funcionan, pero pasará más
tiempo dirigiendo. Las indicaciones específicas
como la anterior a menudo tienen éxito en el primer
intento.

<h3 id="give-claude-something-to-verify-against">
Dé a Claude algo contra lo que verificar
</h3>

Claude funciona mejor cuando puede verificar su

propio trabajo. Incluya casos de prueba, pegue
capturas de pantalla de la interfaz de usuario
esperada o defina la salida que desea.

```text theme={null}
Implementar validateEmail. Casos de prueba:
'user@[Link]' → true,
'invalid' → false, 'user@.com' → false. Ejecute las
pruebas después.
```

Para trabajo visual, pegue una captura de pantalla

del diseño y pida a Claude que compare su
implementación con ella.

<h3 id="explore-before-implementing">
Explorar antes de implementar
</h3>
Manuel Navarro Hidalgo.
Para problemas complejos, separe la investigación
de la codificación. Use plan mode (`Shift+Tab` dos
veces) para analizar la base de código primero:

```text theme={null}
Lea src/auth/ y entienda cómo manejamos sesiones.
Luego cree un plan para agregar soporte OAuth.
```

Revise el plan, refínelo a través de la conversación,

luego deje que Claude implemente. Este enfoque de
dos fases produce mejores resultados que saltar
directamente al código.

<h3 id="delegate-don’t-dictate">
Delegue, no dicte
</h3>

Piense en delegar a un colega capaz. Dé contexto y

dirección, luego confíe en que Claude descubra los
detalles:

```text theme={null}
El flujo de pago está roto para usuarios con tarjetas
vencidas.
El código relevante está en src/payments/. ¿Puede
investigar y arreglarlo?
```
No necesita especificar qué archivos leer o qué
comandos ejecutar. Claude lo descubre.

<h2 id="what’s-next">
Qué sigue
</h2>

<CardGroup cols={2}>
<Card title="Extender con características"
icon="puzzle-piece" href="/es/features-overview">
Agregue Skills, conexiones MCP y comandos
personalizados
</Card>

<Card title="Flujos de trabajo comunes"

icon="graduation-cap"
href="/es/common-workflows">
Guías paso a paso para tareas típicas
</Card>
</CardGroup>

Extender Claude Code

> Comprenda cuándo usar [Link], Skills,

subagents, hooks, MCP y plugins.
Manuel Navarro Hidalgo.
Claude Code combina un modelo que razona sobre
su código con [herramientas
integradas](/es/how-claude-code-works#tools) para
operaciones de archivos, búsqueda, ejecución y
acceso web. Las herramientas integradas cubren la
mayoría de las tareas de codificación. Esta guía
cubre la capa de extensión: características que
agrega para personalizar lo que Claude sabe,
conectarlo a servicios externos y automatizar flujos
de trabajo.

<Note>
Para saber cómo funciona el bucle agentico
central, consulte [Cómo funciona Claude
Code](/es/how-claude-code-works).
</Note>

**¿Nuevo en Claude Code?** Comience con

[[Link]](/es/memory) para convenciones de
proyecto, luego agregue otras extensiones [según
surjan desencadenantes
específicos](#build-your-setup-over-time).

<h2 id="overview">
Descripción general
</h2>

Las extensiones se conectan a diferentes partes del

bucle agentico:
* **[[Link]](/es/memory)** agrega contexto
persistente que Claude ve en cada sesión
* **[Skills](/es/skills)** agregan conocimiento
reutilizable y flujos de trabajo invocables
* **[Code
intelligence](/es/tools-reference#lsp-tool-behavior)**
conecta Claude a un servidor de lenguaje para
navegación a nivel de símbolo y errores de tipo en
vivo
* **[MCP](/es/mcp)** conecta Claude a servicios y
herramientas externas
* **[Subagents](/es/sub-agents)** ejecutan sus
propios bucles en contexto aislado, devolviendo
resúmenes
* **[Agent teams](/es/agent-teams)** coordinan
múltiples sesiones independientes con tareas
compartidas y mensajería punto a punto
* **[Hooks](/es/hooks-guide)** se disparan en
eventos del ciclo de vida y pueden ejecutar un
script, solicitud HTTP, prompt o subagent
* **[Plugins](/es/plugins)** y
**[marketplaces](/es/plugin-marketplaces)**
empaquetan y distribuyen estas características

[Skills](/es/skills) son la extensión más flexible. Una

skill es un archivo markdown que contiene
conocimiento, flujos de trabajo o instrucciones.
Puede invocar skills con un comando como
Manuel Navarro Hidalgo.
`/deploy`, o Claude puede cargarlas
automáticamente cuando sea relevante. Las skills
pueden ejecutarse en su conversación actual o en
un contexto aislado a través de subagents.

<h2 id="match-features-to-your-goal">
Hacer coincidir características con su objetivo
</h2>

Las características van desde contexto siempre

activo que Claude ve en cada sesión, hasta
capacidades bajo demanda que usted o Claude
pueden invocar, hasta automatización en segundo
plano que se ejecuta en eventos específicos. La
tabla a continuación muestra qué está disponible y
cuándo tiene sentido cada uno.

| Característica | Qué
hace | Cuándo
usarlo
| Ejemplo
|
| -------------------------------------------------------------- |
--------------------------------------------------------------------- |
---------------------------------------------------------------------------
------------------------ |
---------------------------------------------------------------------------
----------------------------------- |
| **[Link]** |
Contexto persistente cargado en cada conversación
| Convenciones de proyecto, reglas "siempre haz X"
| "Usa pnpm, no npm. Ejecuta pruebas antes de
hacer commit." |
| **Skill** |
Instrucciones, conocimiento y flujos de trabajo que
Claude puede usar | Contenido reutilizable,
documentos de referencia, tareas repetibles
| `/deploy` ejecuta su lista de verificación de
implementación; skill de documentos API con
patrones de endpoint |
| **Subagent** |
Contexto de ejecución aislado que devuelve
resultados resumidos | Aislamiento de contexto,
tareas paralelas, trabajadores especializados
| Tarea de investigación que lee muchos archivos
pero devuelve solo hallazgos clave
|
| **[Agent teams](/es/agent-teams)**
| Coordinar múltiples sesiones independientes de
Claude Code | Investigación paralela,
desarrollo de nuevas características, depuración
con hipótesis competidoras | Generar revisores para
verificar seguridad, rendimiento y pruebas
simultáneamente |
| **[Code
intelligence](/es/tools-reference#lsp-tool-behavior)**
| Navegación y diagnósticos del servidor de
Manuel Navarro Hidalgo.
lenguaje | Lenguajes tipados, bases de
código grandes donde grep es lento o impreciso
| Saltar a la definición de un símbolo en lugar de leer
todo el archivo |
| **MCP** | Conectar
a servicios externos | Datos
o acciones externas
| Consultar su base de datos, publicar en Slack,
controlar un navegador |
| **Hook** | Script,
solicitud HTTP, prompt o subagent desencadenado
por eventos | Automatización que debe ejecutarse
en cada evento coincidente |
Ejecutar ESLint después de cada edición de archivo
|
| **[Artifact](/es/artifacts)** |
Publicar salida de sesión como una página web
privada e interactiva | Salida que desea ver o
compartir visualmente en lugar de como texto de
terminal | Una línea de tiempo de
incidentes que se actualiza mientras Claude
investiga |

**[Plugins](/es/plugins)** son la capa de

empaquetamiento. Un plugin agrupa skills, hooks,
subagents y servidores MCP en una única unidad
instalable. Las skills de plugin tienen espacios de
nombres (como `/my-plugin:review`) para que
múltiples plugins puedan coexistir. Use plugins
cuando desee reutilizar la misma configuración en
múltiples repositorios o distribuir a otros a través de
un **[marketplace](/es/plugin-marketplaces)**.

<h3 id="build-your-setup-over-time">
Construir su configuración con el tiempo
</h3>

No necesita configurar todo de antemano. Cada

característica tiene un desencadenante reconocible,
y la mayoría de los equipos las agregan en
aproximadamente este orden:

| Desencadenante
| Agregar
|
|
:--------------------------------------------------------------------------
------ |
:--------------------------------------------------------------------------
---------------------- |
| Claude se equivoca en una convención o comando
dos veces | Agréguelo a
[[Link]](/es/memory)
|
| Sigue escribiendo el mismo prompt para iniciar
una tarea | Guárdelo como una
[skill](/es/skills) invocable por el usuario
|
Manuel Navarro Hidalgo.
| Pega el mismo manual o procedimiento de varios
pasos en el chat por tercera vez | Capturarlo como
una [skill](/es/skills)
|
| Sigue copiando datos de una pestaña del
navegador que Claude no puede ver | Conecte
ese sistema como un [servidor MCP](/es/mcp)
|
| Claude lee muchos archivos para encontrar dónde
se define o usa un símbolo | Instale un [plugin
de code
intelligence](/es/discover-plugins#code-intelligence)
para su lenguaje |
| Una tarea secundaria inunda su conversación con
salida que no volverá a consultar | Enrutarlo a
través de un [subagent](/es/sub-agents)
|
| Desea que algo suceda cada vez sin preguntar
| Escriba un [hook](/es/hooks-guide)
|
| Un segundo repositorio necesita la misma
configuración | Empaquételo como
un [plugin](/es/plugins)
|

Los mismos desencadenantes le dicen cuándo

actualizar lo que ya tiene. Un error repetido o un
comentario de revisión recurrente es una edición de
[Link], no una corrección única en el chat. Un
flujo de trabajo que sigue ajustando manualmente
es una skill que necesita otra revisión.

<h3 id="compare-similar-features">
Comparar características similares
</h3>

Algunas características pueden parecer similares.

Aquí se explica cómo distinguirlas.

<Tabs>
<Tab title="Skill vs Subagent">
Las skills y los subagents resuelven problemas
diferentes:

* **Skills** son contenido reutilizable que puede

cargar en cualquier contexto
* **Subagents** son trabajadores aislados que se
ejecutan separadamente de su conversación
principal

| Aspecto | Skill
| Subagent
|
| -------------------------------------------------------- |
------------------------------------------------------------- |
---------------------------------------------------------------------------
--- |
Manuel Navarro Hidalgo.
| **Qué es** |
Instrucciones, conocimiento o flujos de trabajo
reutilizables | Trabajador aislado con su propio
contexto |
| **Beneficio clave** |
Compartir contenido entre contextos
| Aislamiento de contexto. El trabajo ocurre por
separado, solo devuelve resumen |
| **Impacto de [ventana de
contexto](/es/context-window)** | Se agrega a su
ventana principal | Usa una ventana
separada con sus propios tokens de entrada y
salida |
| **Mejor para** | Material
de referencia, flujos de trabajo invocables |
Tareas que leen muchos archivos, trabajo paralelo,
trabajadores especializados |

**Las skills pueden ser de referencia o acción.**

Las skills de referencia proporcionan conocimiento
que Claude usa en toda su sesión (como su guía de
estilo de API). Las skills de acción le dicen a Claude
que haga algo específico (como `/deploy` que
ejecuta su flujo de trabajo de implementación).

**Use un subagent** cuando necesite aislamiento

de contexto o cuando su ventana de contexto se
esté llenando. El subagent podría leer docenas de
archivos o ejecutar búsquedas extensas, pero su
conversación principal solo recibe un resumen.
Dado que el trabajo del subagent no consume su
contexto principal, esto también es útil cuando no
necesita que el trabajo intermedio permanezca
visible. Los subagents personalizados pueden tener
sus propias instrucciones y pueden precargar skills.

**Pueden combinarse.** Un subagent puede

precargar skills específicas (campo `skills:`). Una
skill puede ejecutarse en contexto aislado usando
`context: fork`. Consulte [Skills](/es/skills) para
obtener detalles.
</Tab>

<Tab title="[Link] vs Skill">

Ambos almacenan instrucciones, pero se cargan
de manera diferente y sirven propósitos diferentes.

| Aspecto | [Link]
| Skill |
| ---------------------------------------- |
----------------------------- |
---------------------------------------------------- |
| **Se carga** | Cada sesión,
automáticamente | Bajo demanda
|
| **Puede incluir archivos** | Sí, con
importaciones `@path` | Sí, con importaciones
`@path` |
Manuel Navarro Hidalgo.
| **Puede desencadenar flujos de trabajo** | No
| Sí, con `/<name>` |
| **Mejor para** | Reglas "siempre
haz X" | Material de referencia, flujos de trabajo
invocables |

**Póngalo en [Link]** si Claude siempre

debe saberlo: convenciones de codificación,
comandos de compilación, estructura del proyecto,
reglas "nunca hagas X".

**Póngalo en una skill** si es material de

referencia que Claude necesita a veces
(documentos de API, guías de estilo) o un flujo de
trabajo que desencadena con `/<name>`
(implementar, revisar, lanzar).

**Regla general:** Mantenga [Link] bajo 200

líneas. Si está creciendo, mueva contenido de
referencia a skills o divida en archivos
[`.claude/rules/`](/es/memory#organize-rules-with-cla
ude%2Frules%2F).
</Tab>

<Tab title="[Link] vs Rules vs Skills">

Los tres almacenan instrucciones, pero se cargan
de manera diferente:
 | Aspecto | [Link]
| `.claude/rules/` | Skill
|
| -------------- | ------------------------------------------------ |
---------------------------------------------------- |
---------------------------------------------------- |
| **Se carga** | Cada sesión
| Cada sesión, o cuando se abren archivos
coincidentes | Bajo demanda, cuando se invoca o es
relevante |
| **Alcance** | Proyecto completo
| Puede estar limitado a rutas de archivo |
Específico de tarea |
| **Mejor para** | Convenciones y comandos de
compilación centrales | Directrices específicas del
idioma o directorio | Material de referencia, flujos
de trabajo repetibles |

**Use [Link]** para instrucciones que cada

sesión necesita: comandos de compilación,
convenciones de prueba, arquitectura del proyecto.

**Use rules** para mantener [Link]

enfocado. Las rules con [frontmatter
`paths`](/es/memory#path-specific-rules) solo se
cargan cuando Claude trabaja con archivos
coincidentes, ahorrando contexto.
Manuel Navarro Hidalgo.
**Use skills** para contenido que Claude solo
necesita a veces, como documentación de API o
una lista de verificación de implementación que
desencadena con `/<name>`.
</Tab>

<Tab title="Subagent vs Agent team">

Ambos paralelizan el trabajo, pero son
arquitectónicamente diferentes:

* **Subagents** se ejecutan dentro de su sesión e

informan resultados de vuelta a su contexto
principal
* **Agent teams** son sesiones independientes de
Claude Code que se comunican entre sí

| Aspecto | Subagent
| Agent team |
| ------------------ |
--------------------------------------------------------------- |
--------------------------------------------------------- |
| **Contexto** | Ventana de contexto propia;
los resultados regresan al llamador | Ventana de
contexto propia; completamente independiente |
| **Comunicación** | Informa resultados solo al
agente principal | Los compañeros se
envían mensajes directamente entre sí |
 | **Coordinación** | El agente principal gestiona
todo el trabajo | Lista de tareas
compartida con auto-coordinación |
| **Mejor para** | Tareas enfocadas donde solo
importa el resultado | Trabajo complejo que
requiere discusión y colaboración |
| **Costo de token** | Menor: resultados
resumidos de vuelta al contexto principal | Mayor:
cada compañero es una instancia separada de
Claude |

**Use un subagent** cuando necesite un

trabajador rápido y enfocado: investigar una
pregunta, verificar una afirmación, revisar un
archivo. El subagent hace el trabajo y devuelve un
resumen. Su conversación principal se mantiene
limpia.

**Use un agent team** cuando los compañeros

necesiten compartir hallazgos, desafiarse
mutuamente y coordinarse de forma independiente.
Los agent teams son mejores para investigación
con hipótesis competidoras, revisión de código
paralela y desarrollo de nuevas características
donde cada compañero posee una pieza separada.

**Punto de transición:** Si está ejecutando

subagents paralelos pero alcanzando límites de
contexto, o si sus subagents necesitan comunicarse
Manuel Navarro Hidalgo.
entre sí, los agent teams son el siguiente paso
natural.

<Note>
Los agent teams son experimentales y están
deshabilitados por defecto. Consulte [agent
teams](/es/agent-teams) para configuración y
limitaciones actuales.
</Note>
</Tab>

<Tab title="MCP vs Skill">

MCP conecta Claude a servicios externos. Las
skills extienden lo que Claude sabe, incluyendo
cómo usar esos servicios de manera efectiva.

| Aspecto | MCP
| Skill
|
| --------------- |
---------------------------------------------------------------------- |
---------------------------------------------------------------------------
--------------------------- |
| **Qué es** | Protocolo para conectar a
servicios externos | Conocimiento,
flujos de trabajo y material de referencia
|
 | **Proporciona** | Herramientas y acceso a datos
| Conocimiento, flujos de trabajo, material de
referencia |
| **Ejemplos** | Integración de Slack, consultas
de base de datos, control de navegador | Lista de
verificación de revisión de código, flujo de trabajo
de implementación, guía de estilo de API |

Estos resuelven problemas diferentes y funcionan

bien juntos:

**MCP** le da a Claude herramientas

especialmente diseñadas para un sistema externo,
con la conexión y autenticación manejadas por el
servidor.

**Skills** le dan a Claude conocimiento sobre

cómo usar esas herramientas de manera efectiva,
además de flujos de trabajo que puede
desencadenar con `/<name>`. Una skill podría incluir
el esquema de base de datos de su equipo y
patrones de consulta, o un flujo de trabajo
`/post-to-slack` con las reglas de formato de
mensaje de su equipo.

Ejemplo: Un servidor MCP conecta Claude a su

base de datos. Una skill enseña a Claude su modelo
de datos, patrones de consulta comunes y qué
tablas usar para diferentes tareas.
Manuel Navarro Hidalgo.
</Tab>

<Tab title="Hook vs Skill">

Un hook se dispara en un evento del ciclo de
vida; una skill se carga en contexto para que Claude
la aplique.

| Aspecto | Hook
| Skill
|
| --------------------- |
---------------------------------------------------------------------------
----------- |
---------------------------------------------------------------------------
----------------- |
| **Se ejecuta** | Un comando shell, solicitud
HTTP, prompt LLM o subagent |
Instrucciones que Claude lee y sigue
|
| **Desencadenado por** | [Eventos del ciclo de
vida](/es/hooks#hook-events) como `PostToolUse` o
`SessionStart` | Usted escribiendo `/<name>`, o
Claude haciendo coincidir la descripción con su
tarea |
| **Determinismo** | Siempre se dispara en su
evento; el desencadenante está garantizado
| Claude interpreta las instrucciones; el resultado
puede variar |
 | **Costo de contexto** | Cero a menos que el
hook devuelva salida | La
descripción se carga cada sesión; el contenido
completo se carga cuando se usa |
| **Mejor para** | Linting después de
ediciones, bloquear comandos inseguros, logging,
notificaciones | Flujos de trabajo que necesitan
razonamiento, material de referencia, tareas de
varios pasos |

**Use un hook** cuando la acción debe suceder

de la misma manera cada vez y no necesita que
Claude piense. Por ejemplo: formatear al guardar,
rechazar `rm -rf /`, publicar un mensaje de Slack
cuando termina una sesión.

**Use una skill** cuando Claude debe decidir

cómo aplicar los pasos, o cuando el contenido es
conocimiento en lugar de un script. Por ejemplo:
una lista de verificación `/release`, su guía de estilo
de API, un manual de depuración.

**Ponga guardrails en hooks.** Una instrucción

como "nunca edite `.env`" en [Link] o una
skill es una solicitud, no una garantía. Un hook
`PreToolUse` que bloquea la edición es
cumplimiento. Si una regla debe mantenerse cada
vez, hágala un hook en lugar de una instrucción de
prompt.
Manuel Navarro Hidalgo.

**La salida del hook aterriza en contexto.** Un

hook `PostToolUse` que ejecuta su linter alimenta
resultados de vuelta como texto que Claude lee; una
skill `/fix-lint` le dice a Claude cómo resolverlos.
</Tab>
</Tabs>

<h3 id="understand-how-features-layer">
Entender cómo se superponen las características
</h3>

Las características se pueden definir en múltiples

niveles: en todo el usuario, por proyecto, a través de
plugins o mediante políticas administradas.
También puede anidar archivos [Link] en
subdirectorios o colocar skills en paquetes
específicos de un monorepo. Cuando la misma
característica existe en múltiples niveles, así es
como se superponen:

* **Los archivos [Link]** son aditivos: todos

los niveles contribuyen contenido al contexto de
Claude simultáneamente. Los archivos de su
directorio de trabajo y superior se cargan al iniciar;
los subdirectorios se cargan mientras trabaja en
ellos. Cuando las instrucciones entran en conflicto,
Claude usa el juicio para reconciliarlas, con
instrucciones más específicas típicamente teniendo
precedencia. Consulte [cómo se cargan los archivos
[Link]](/es/memory#how-claude-md-files-load
).
* **Las skills y subagents** se anulan por nombre:
cuando el mismo nombre existe en múltiples
niveles, una definición gana según la prioridad
(administrado > usuario > proyecto para skills;
administrado > bandera CLI > proyecto > usuario >
plugin para subagents). Las skills de plugin tienen
[espacios de
nombres](/es/plugins#add-skills-to-your-plugin)
para evitar conflictos. Consulte [descubrimiento de
skills](/es/skills#where-skills-live) y [alcance de
subagent](/es/sub-agents#choose-the-subagent-sco
pe).
* **Los servidores MCP** se anulan por nombre:
local > proyecto > usuario. Consulte [alcance de
MCP](/es/mcp#scope-hierarchy-and-precedence).
* **Los hooks** se fusionan: todos los hooks
registrados se disparan para sus eventos
coincidentes independientemente de la fuente.
Consulte [hooks](/es/hooks).

<h3 id="combine-features">
Combinar características
</h3>

Cada extensión resuelve un problema diferente:

[Link] maneja contexto siempre activo, las
Manuel Navarro Hidalgo.
skills manejan conocimiento bajo demanda y flujos
de trabajo, MCP maneja conexiones externas, los
subagents manejan aislamiento y los hooks
manejan automatización. Las configuraciones reales
las combinan según su flujo de trabajo.

Por ejemplo, podría usar [Link] para

convenciones de proyecto, una skill para su flujo de
trabajo de implementación, MCP para conectar a su
base de datos y un hook para ejecutar linting
después de cada edición. Cada característica
maneja lo que hace mejor.

| Patrón | Cómo funciona

| Ejemplo
|
| ---------------------- |
---------------------------------------------------------------------------
-------------------------------- |
---------------------------------------------------------------------------
------------------------------ |
| **Skill + MCP** | MCP proporciona la conexión;
una skill enseña a Claude cómo usarla bien
| MCP se conecta a su base de datos, una skill
documenta su esquema y patrones de consulta
|
| **Skill + Subagent** | Una skill genera subagents
para trabajo paralelo
| La skill `/audit` inicia subagents de seguridad,
rendimiento y estilo que trabajan en contexto
aislado |
| **[Link] + Skills** | [Link] contiene
reglas siempre activas; las skills contienen material
de referencia cargado bajo demanda | [Link]
dice "sigue nuestras convenciones de API," una
skill contiene la guía de estilo de API completa |
| **Hook + MCP** | Un hook desencadena
acciones externas a través de MCP
| El hook post-edición envía una notificación de
Slack cuando Claude modifica archivos críticos
|

<h2 id="understand-context-costs">
Entender costos de contexto
</h2>

Cada característica que agrega consume algo del

contexto de Claude. Demasiado puede llenar su
ventana de contexto, pero también puede agregar
ruido que hace que Claude sea menos efectivo; las
skills pueden no desencadenarse correctamente, o
Claude puede perder de vista sus convenciones.
Entender estos compromisos lo ayuda a construir
una configuración efectiva. Para una vista
interactiva de cómo estas características se
combinan en una sesión en ejecución, consulte
[Explorar la ventana de
contexto](/es/context-window).
Manuel Navarro Hidalgo.

<h3 id="context-cost-by-feature">
Costo de contexto por característica
</h3>

Cada característica tiene una estrategia de carga y

costo de contexto diferentes:

| Característica | Cuándo se carga

| Qué se carga |
Costo de contexto |
| -------------------------- |
---------------------------------------------- |
---------------------------------------------------------------------- |
----------------------------------------------------- |
| **[Link]** | Inicio de sesión
| Contenido completo
| Cada solicitud |
| **Skills** | Inicio de sesión + cuando se
usa | Descripciones al inicio, contenido
completo cuando se usa | Bajo
(descripciones cada solicitud)\* |
| **Servidores MCP** | Inicio de sesión
| Nombres de herramientas; esquemas completos
bajo demanda | Bajo hasta que se usa una
herramienta |
| **Inteligencia de código** | Después de ediciones
de archivo y bajo demanda | Diagnósticos después
de ediciones; ubicaciones de símbolos en búsqueda
| Bajo; reduce lecturas de archivo en otros lugares
|
| **Subagents** | Cuando se generan
| Contexto fresco con skills especificadas
| Aislado de la sesión principal |
| **Hooks** | Al desencadenar
| Nada (se ejecuta externamente)
| Cero, a menos que el hook devuelva contexto
adicional |

\*Por defecto, las descripciones de skills se cargan

al inicio de sesión para que Claude pueda decidir
cuándo usarlas. Establezca
`disable-model-invocation: true` en el frontmatter de
una skill para ocultarla de Claude completamente
hasta que la invoque manualmente. Esto reduce el
costo de contexto a cero para las skills que solo
desencadena usted mismo. Para una skill que no
escribió, establezca
[`skillOverrides`](/es/skills#override-skill-visibility-fr
om-settings) en la configuración para hacer lo
mismo sin editar su archivo.

<h3 id="understand-how-features-load">
Entender cómo se cargan las características
</h3>
Manuel Navarro Hidalgo.
Cada característica se carga en diferentes puntos de
su sesión. Las pestañas a continuación explican
cuándo se carga cada una y qué entra en contexto.

<img
src="[Link]
ahteV/images/[Link]?fit=max&auto=for
mat&n=ikqp3_70mqIahteV&q=85&s=aab139e750494
a237ae2e0c8f9139b0a" alt="Carga de contexto:
[Link] se carga al inicio de sesión y
permanece en cada solicitud. Los nombres de
herramientas MCP se cargan al inicio con esquemas
completos diferidos hasta el uso. Las skills cargan
descripciones al inicio, contenido completo al
invocar. Los subagents obtienen contexto aislado.
Los hooks se ejecutan externamente." width="720"
height="382"
data-path="images/[Link]" />

<Tabs>
<Tab title="[Link]">
**Cuándo:** Inicio de sesión

**Qué se carga:** Contenido completo de todos

los archivos [Link] (niveles administrado,
usuario y proyecto).

**Herencia:** Claude lee archivos [Link] de

su directorio de trabajo hasta la raíz, y descubre los
anidados en subdirectorios mientras accede a esos
archivos. Consulte [Cómo se cargan los archivos
[Link]](/es/memory#how-claude-md-files-load
) para obtener detalles.

<Tip>Mantenga [Link] bajo 200 líneas.

Mueva material de referencia a skills, que se cargan
bajo demanda.</Tip>
</Tab>

<Tab title="Skills">
Las skills son capacidades adicionales en el kit
de herramientas de Claude. Pueden ser material de
referencia (como una guía de estilo de API) o flujos
de trabajo invocables que desencadena con
`/<name>` (como `/deploy`). Claude Code incluye
[skills incluidas](/es/commands) como
`/code-review`, `/batch` y `/debug` que funcionan de
inmediato. También puede crear las suyas propias.
Claude usa skills cuando es apropiado, o puede
invocar una directamente.

**Cuándo:** Depende de la configuración de la

skill. Por defecto, las descripciones se cargan al
inicio de sesión y el contenido completo se carga
cuando se usa. Para skills solo de usuario
(`disable-model-invocation: true`), nada se carga
hasta que las invoque.
Manuel Navarro Hidalgo.
**Qué se carga:** Para skills invocables por
modelo, Claude ve nombres y descripciones en
cada solicitud. Cuando invoca una skill con
`/<name>` o Claude la carga automáticamente, el
contenido completo se carga en su conversación.

**Cómo Claude elige skills:** Claude hace

coincidir su tarea contra descripciones de skills
para decidir cuáles son relevantes. Si las
descripciones son vagas u se superponen, Claude
puede cargar la skill incorrecta o perder una que
ayudaría. Para decirle a Claude que use una skill
específica, invóquela con `/<name>`. Las skills con
`disable-model-invocation: true` son invisibles para
Claude hasta que las invoque.

**Costo de contexto:** Bajo hasta que se use. Las

skills solo de usuario tienen costo cero hasta que se
invoquen.

**En subagents:** Las skills funcionan de manera

diferente en subagents. En lugar de carga bajo
demanda, las skills listadas en el campo `skills` del
subagent se precarga completamente en su
contexto al iniciar. Los subagents aún pueden
descubrir e invocar skills de proyecto, usuario y
plugin no listadas a través de la herramienta Skill.
 <Tip>Use `disable-model-invocation: true` para
skills con efectos secundarios. Esto ahorra contexto
y asegura que solo usted las desencadene.</Tip>
</Tab>

<Tab title="Servidores MCP">

**Cuándo:** Inicio de sesión.

**Qué se carga:** Nombres de herramientas de

servidores conectados. Los esquemas JSON
completos permanecen diferidos hasta que Claude
necesita una herramienta específica.

**Costo de contexto:** [Búsqueda de

herramientas](/es/mcp#scale-with-mcp-tool-search)
está habilitada por defecto, por lo que las
herramientas MCP inactivas consumen contexto
mínimo.

<Tip>Ejecute `/mcp` para ver estado de conexión

y costos de token por servidor. Claude Code [se
reconecta automáticamente a servidores
remotos](/es/mcp#automatic-reconnection) si se
desconectan, y puede desconectar servidores que
no esté usando activamente.</Tip>
</Tab>

<Tab title="Inteligencia de código">

Manuel Navarro Hidalgo.
**Cuándo:** Después de ediciones de archivo, y
bajo demanda cuando Claude navega código.

**Qué se carga:** Errores de tipo y advertencias

después de cada edición de archivo. Información de
definición, referencia y tipo cuando Claude busca
un símbolo.

**Costo de contexto:** Bajo. Las búsquedas de

símbolos a menudo reemplazan lecturas amplias de
archivos, por lo que el uso neto de contexto puede
disminuir.

<Tip>La herramienta LSP está inactiva hasta que

instale un [plugin de inteligencia de
código](/es/discover-plugins#code-intelligence) para
su lenguaje.</Tip>
</Tab>

<Tab title="Subagents">
**Cuándo:** Bajo demanda, cuando usted o
Claude genera uno para una tarea.

**Qué se carga:** Contexto fresco y aislado que

contiene:

* El prompt del sistema del agente, no el prompt

del sistema completo de Claude Code
 * Contenido completo de skills listadas en el
campo `skills` del agente
* [Link] y estado de git, excepto los
agentes Explore y Plan integrados [omiten
ambos](/es/sub-agents#what-loads-at-startup)
* Cualquier contexto que el agente principal pase
en el prompt

**Costo de contexto:** Aislado de la sesión

principal. Los subagents no heredan su historial de
conversación o skills invocadas.

<Tip>Use subagents para trabajo que no necesita

su contexto de conversación completo. Su
aislamiento previene inflar su sesión
principal.</Tip>
</Tab>

<Tab title="Hooks">
**Cuándo:** Al desencadenar. Los hooks se
disparan en eventos de ciclo de vida específicos
como ejecución de herramientas, límites de sesión,
envío de prompt, solicitudes de permiso y
compactación. Consulte [Hooks](/es/hooks) para la
lista completa.

**Qué se carga:** Nada por defecto. Los hooks se

ejecutan fuera de la conversación principal.
Manuel Navarro Hidalgo.
**Costo de contexto:** Cero, a menos que el hook
devuelva salida que se agregue como mensajes a su
conversación.

<Tip>Los hooks son ideales para efectos

secundarios (linting, logging) que no necesitan
afectar el contexto de Claude.</Tip>
</Tab>
</Tabs>

<h2 id="learn-more">
Aprender más
</h2>

Cada característica tiene su propia guía con

instrucciones de configuración, ejemplos y
opciones de configuración.

<CardGroup cols={2}>
<Card title="[Link]" icon="file-lines"
href="/es/memory">
Almacenar contexto de proyecto, convenciones e
instrucciones
</Card>

<Card title="Skills" icon="brain" href="/es/skills">

Dar a Claude experiencia de dominio y flujos de
trabajo reutilizables
</Card>
 <Card title="Subagents" icon="users"
href="/es/sub-agents">
Descargar trabajo a contexto aislado
</Card>

<Card title="Agent teams" icon="network"

href="/es/agent-teams">
Coordinar múltiples sesiones trabajando en
paralelo
</Card>

<Card title="MCP" icon="plug" href="/es/mcp">

Conectar Claude a servicios externos
</Card>

<Card title="Hooks" icon="bolt"

href="/es/hooks-guide">
Automatizar acciones con hooks
</Card>

<Card title="Plugins" icon="puzzle-piece"

href="/es/plugins">
Empaquetar y compartir conjuntos de
características
</Card>

<Card title="Marketplaces" icon="store"

href="/es/plugin-marketplaces">
Manuel Navarro Hidalgo.
Alojar y distribuir colecciones de plugins
</Card>
</CardGroup>

Explorar el directorio .claude

> Dónde Claude Code lee [Link],

[Link], hooks, skills, commands, subagents,
workflows, rules y auto memory. Explore el
directorio .claude en su proyecto y ~/.claude en su
directorio de inicio.

export const ClaudeExplorer = () => {

const A = useMemo(() => ({href, children}) => <a
href={href} style={{
color: 'var(--ce-accent)',
textDecoration: 'none',
borderBottom: '1px dotted var(--ce-accent)'
}}>{children}</a>, []);
const C = useMemo(() => ({children}) => <code
style={{
fontFamily: 'var(--ce-mono)',
fontSize: '0.92em',
padding: '1px 4px',
borderRadius: '3px',
background: 'var(--ce-surface)',
border: '0.5px solid var(--ce-border-subtle)'
}}>{children}</code>, []);
 const commandsNote = useMemo(() =>
<>Commands and skills are now the same
mechanism. For new workflows, use <A
href="/en/skills">skills/</A> instead: same
<C>/name</C> invocation, plus you can bundle
supporting files.</>, []);
const FILE_TREE = useMemo(() => ({
project: {
label: 'your-project/',
children: [{
id: 'claude-md',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#6A9BCC',
badge: 'committed',
oneLiner: 'Project instructions Claude reads
every session',
when: 'Loaded into context at the start of every
session',
description: 'Project-specific instructions that
shape how Claude works in this repository. Put your
conventions, common commands, and architectural
context here so Claude operates with the same
assumptions your team does.',
tips: ['Target under 200 lines. Longer files still
load in full but may reduce adherence',
<>[Link] loads into every session. If
something only matters for specific tasks, move it to
Manuel Navarro Hidalgo.
a <A href="/en/skills">skill</A> or a path-scoped <A
href="/en/memory#organize-rules-with-claude/rules/
">rule</A> so it loads only when needed</>, 'List the
commands you run most, like build, test, and
format, so Claude knows them without you spelling
them out each time', <>Run <C>/memory</C> to
open and edit [Link] from within a session</>,
<>Also works at <C>.claude/[Link]</C> if you
prefer to keep the project root clean</>],
exampleIntro: 'This example is for a TypeScript
and React project. It lists the build and test
commands, the framework conventions Claude
should follow, and project-specific rules like export
style and file layout.',
example: `# Project conventions

## Commands
- Build: \`npm run build\`
- Test: \`npm test\`
- Lint: \`npm run lint\`

## Stack
- TypeScript with strict mode
- React 19, functional components only

## Rules
- Named exports, never default exports
- Tests live next to source: \`[Link]\` -> \`[Link]\`
- All API routes return \`{ data, error }\` shape`,
 docsLink: '/en/memory'
}, {
id: 'mcp-json',
label: '.[Link]',
type: 'file',
icon: 'json',
color: '#9B7BC4',
badge: 'committed',
oneLiner: 'Project-scoped MCP servers, shared
with your team',
when: <>Servers connect when the session
begins. Tool schemas are deferred by default and
load on demand via <A
href="/en/mcp#scale-with-mcp-tool-search">tool
search</A></>,
description: <>Configures Model Context
Protocol (MCP) servers that give Claude access to
external tools: databases, APIs, browsers, and
more. This file holds the project-scoped servers
your whole team uses. Personal servers you want to
keep to yourself go in <C>~/.[Link]</C>
instead.</>,
tips: [<>Use environment variable references
for secrets: <C>{'${GITHUB_TOKEN}'}</C></>,
<>Lives at the project root, not inside
<C>.claude/</C></>, <>For servers only you need,
run <C>claude mcp add --scope user</C>. This
writes to <C>~/.[Link]</C> instead of
<C>.[Link]</C></>],
Manuel Navarro Hidalgo.
exampleIntro: <>This example configures the
GitHub MCP server so Claude can read issues and
open pull requests. The
<C>{'${GITHUB_TOKEN}'}</C> reference is read
from your shell environment when Claude Code
starts the server, so the token never lands in the
file.</>,
example: `{
"mcpe Servers": {
"github": {
"command": "npx",
"args": ["-y",
"@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "\${GITHUB_TOKEN}"
}
}
}
}`,
docsLink: '/en/mcp'
}, {
id: 'worktreeinclude',
label: '.worktreeinclude',
type: 'file',
icon: 'md',
color: '#8FA876',
badge: 'committed',
oneLiner: 'Gitignored files to copy into new
worktrees',
 when: <>Read when Claude creates a git
worktree via <C>--worktree</C>, the
<C>EnterWorktree</C> tool, or subagent
<C>isolation: worktree</C></>,
description: <>Lists gitignored files to copy
from your main repository into each new worktree.
Worktrees are fresh checkouts, so untracked files
like <C>.env</C> are missing by default. Patterns
here use <C>.gitignore</C> syntax. Only files that
match a pattern and are also gitignored get copied,
so tracked files are never duplicated.</>,
tips: [<>Lives at the project root, not inside
<C>.claude/</C></>, <>Git-only: if you configure a
<A
href="/en/hooks#worktreecreate">WorktreeCreate
hook</A> for a different VCS, this file is not read.
Copy files inside your hook script instead</>,
<>Also applies to parallel sessions in the <A
href="/en/desktop#work-in-parallel-with-sessions">d
esktop app</A></>],
exampleIntro: 'This example copies your local
environment files and a secrets config into every
worktree Claude creates. Comments start with # and
blank lines are ignored, same as .gitignore.',
example: `# Local environment
.env
.[Link]

# API credentials
Manuel Navarro Hidalgo.
config/[Link]`,
docsLink:
'/en/worktrees#copy-gitignored-files-into-worktrees'
}, {
id: 'dot-claude',
label: '.claude/',
type: 'folder',
icon: 'folder',
color: 'var(--ce-accent)',
oneLiner: 'Project-level configuration, rules,
and extensions',
description: 'Everything Claude Code reads
that is specific to this project. If you use git, commit
most files here so your team shares them; a few, like
[Link], are automatically gitignored.
Each file badge shows which.',
children: [{
id: 'settings-json',
label: '[Link]',
type: 'file',
icon: 'json',
color: 'var(--ce-text-3)',
badge: 'committed',
oneLiner: 'Permissions, hooks, and
configuration',
when: <>Overrides global
<C>~/.claude/[Link]</C>. Local settings, CLI
flags, and managed settings override this</>,
 description: 'Settings that Claude Code
applies directly. Permissions control which
commands and tools Claude can use; hooks run
your scripts at specific points in a session. Unlike
[Link], which Claude reads as guidance,
these are enforced whether Claude follows them or
not.',
contains: [<><A
href="/en/permissions">permissions</A>: allow,
deny, or prompt before Claude uses specific tools or
commands</>, <><A href="/en/hooks">hooks</A>:
run your own scripts on events like before a tool call
or after a file edit</>, <><A
href="/en/statusline">statusLine</A>: customize the
line shown at the bottom while Claude works</>,
<><A
href="/en/settings#available-settings">model</A>:
pick a default model for this project</>, <><A
href="/en/settings#environment-variables">env</A>:
environment variables set in every session</>, <><A
href="/en/output-styles">outputStyle</A>: select a
custom system-prompt style from output-styles/</>],
tips: [<>Bash permission patterns support
wildcards: <C>Bash(npm test *)</C> matches any
command starting with <C>npm test</C></>,
<>Array settings like <C>[Link]</C>
combine across all scopes; scalar settings like
<C>model</C> use the most specific value</>],
Manuel Navarro Hidalgo.
exampleIntro: <>This example allows <C>npm
test</C> and <C>npm run</C> commands without
prompting, blocks <C>rm -rf</C>, and runs Prettier
on files after Claude edits or writes them.</>,
example: `{
"permissions": {
"allow": [
"Bash(npm test *)",
"Bash(npm run *)"
],
"deny": [
"Bash(rm -rf *)"
]
},
"hooks": {
"PostToolUse": [{
"matcher": "Edit|Write",
"hooks": [{
"type": "command",
"command": "jq -r '.tool_input.file_path' | xargs
npx prettier --write"
}]
}]
}
}`,
docsLink: '/en/settings'
}, {
id: 'settings-local-json',
label: '[Link]',
 type: 'file',
icon: 'json',
color: 'var(--ce-text-3)',
badge: 'gitignored',
oneLiner: 'Your personal settings overrides for
this project',
when: 'Highest of the user-editable settings
files; CLI flags and managed settings still take
precedence',
description: 'Personal settings that take
precedence over the project defaults. Same JSON
format as [Link], but not committed. Use this
when you need different permissions or defaults
than the team config.',
tips: [<>Same schema as [Link]. Array
settings like <C>[Link]</C> combine
across scopes; scalar settings like <C>model</C>
use the local value</>, <>Claude Code adds this file
to <C>~/.config/git/ignore</C> the first time it writes
one. If you use a custom <C>[Link]</C>,
add the pattern there too. To share the ignore rule
with your team, also add it to the project
<C>.gitignore</C></>],
exampleIntro: 'This example adds Docker
permissions on top of whatever the team
[Link] allows.',
example: `{
"permissions": {
"allow": [
Manuel Navarro Hidalgo.
"Bash(docker *)"
]
}
}`,
docsLink: '/en/settings'
}, {
id: 'rules',
label: 'rules/',
type: 'folder',
icon: 'folder',
color: '#9B7BC4',
oneLiner: 'Topic-scoped instructions,
optionally gated by file paths',
when: <>Rules without <C>paths:</C> load at
session start. Rules with <C>paths:</C> load when a
matching file enters context</>,
description: [<>Project instructions split into
topic files that can load conditionally based on file
paths. A rule without <C>paths:</C> frontmatter
loads at session start like [Link]; a rule with
<C>paths:</C> loads only when Claude reads a
matching file.</>, <>Like [Link], rules are
guidance Claude reads, not configuration Claude
Code enforces. For guaranteed behavior use <A
href="/en/hooks">hooks</A> or <A
href="/en/permissions">permissions</A>.</>],
tips: [<>Use <C>paths:</C> frontmatter with
globs to scope rules to directories or file types</>,
<>Subdirectories work:
<C>.claude/rules/frontend/[Link]</C> is
discovered automatically</>, 'When [Link]
approaches 200 lines, start splitting into rules'],
docsLink:
'/en/memory#organize-rules-with-claude/rules/',
children: [{
id: 'rule-testing',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#9B7BC4',
badge: 'committed',
oneLiner: 'Test conventions scoped to test
files',
when: <>Loaded when Claude reads a file
matching the <C>paths:</C> globs below</>,
description: <>An example rule that only
loads when Claude is working on test files. The
<C>paths:</C> globs in the frontmatter define which
files trigger it; here, anything ending in .[Link] or
.[Link]. For other files, this rule is not loaded into
context.</>,
example: `---
paths:
- "**/*.[Link]"
- "**/*.[Link]"
---

# Testing Rules
Manuel Navarro Hidalgo.

- Use descriptive test names: "should [expected]

when [condition]"
- Mock external dependencies, not internal modules
- Clean up side effects in afterEach`
}, {
id: 'rule-api',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#9B7BC4',
badge: 'committed',
oneLiner: 'API conventions scoped to
backend code',
when: <>Loaded when Claude reads a file
matching the <C>paths:</C> glob below</>,
description: <>A second example showing a
rule scoped to backend code. The <C>paths:</C>
glob matches files under src/api/, so these
conventions load only when Claude is editing API
routes.</>,
example: `---
paths:
- "src/api/**/*.ts"
---

# API Design Rules

- All endpoints must validate input with Zod
schemas
- Return shape: { data: T } | { error: string }
- Rate limit all public endpoints`
}]
}, {
id: 'skills',
label: 'skills/',
type: 'folder',
icon: 'folder',
color: '#D4A843',
oneLiner: 'Reusable prompts you or Claude
invoke by name',
when: <>Invoked with <C>/skill-name</C> or
when Claude matches the task to a skill</>,
description: <>Each skill is a folder with a
[Link] file plus any supporting files it needs. By
default, both you and Claude can invoke a skill. Use
frontmatter to control that:
<C>disable-model-invocation: true</C> for user-only
workflows like <C>/deploy</C>, or
<C>user-invocable: false</C> to hide from the
<C>/</C> menu while Claude can still invoke it.</>,
tips: [<>Skills accept arguments: <C>/deploy
staging</C> passes "staging" as
<C>$ARGUMENTS</C>. Use <C>$0</C>, <C>$1</C>,
and so on for positional access</>, <>The
<C>description</C> frontmatter determines when
Claude auto-invokes the skill</>, 'Bundle reference
Manuel Navarro Hidalgo.
docs alongside [Link]. Claude knows the skill
directory path and can read supporting files when
you mention them'],
docsLink: '/en/skills',
children: [{
id: 'skill-review',
label: 'security-review/',
type: 'folder',
icon: 'folder',
color: '#D4A843',
oneLiner: 'A skill bundling [Link] with
supporting files',
children: [{
id: 'skill-review-md',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#D4A843',
badge: 'committed',
oneLiner: 'Entrypoint: trigger, invocability,
instructions',
when: <>User types <C>/security-review
&lt;target&gt;</C>; Claude cannot auto-invoke this
skill</>,
description: [<>This skill uses
<C>disable-model-invocation: true</C> so only you
can trigger it; Claude never invokes it on its own.</>,
<>The <C>!`...`</C> line runs a shell command and
injects its output into the prompt.
<C>$ARGUMENTS</C> substitutes whatever you
typed after the skill name. Claude sees the skill
directory path, so mentioning a bundled file like
[Link] lets Claude read it.</>],
example: `---
description: Reviews code changes for security
vulnerabilities, authentication gaps, and injection
risks
disable-model-invocation: true
argument-hint: <branch-or-path>
---

## Diff to review

!\`git diff $ARGUMENTS\`

Audit the changes above for:

1. Injection vulnerabilities (SQL, XSS, command)

2. Authentication and authorization gaps
3. Hardcoded secrets or credentials

Use [Link] in this skill directory for the full

review checklist.

Report findings with severity ratings and

remediation steps.`
}, {
id: 'skill-checklist',
Manuel Navarro Hidalgo.
label: '[Link]',
type: 'file',
icon: 'md',
color: '#D4A843',
badge: 'committed',
oneLiner: 'Supporting file bundled with the
skill',
when: 'Claude reads it on demand while
running the skill',
description: <>Skills can bundle any
supporting files: reference docs, templates, scripts.
The skill directory path is prepended to [Link],
so Claude can read bundled files by name. For
scripts in bash injection commands, use the
<C>{'${CLAUDE_SKILL_DIR}'}</C> placeholder.</>,
example: `# Security Review Checklist

## Input Validation
- [ ] All user input sanitized before DB queries
- [ ] File upload MIME types validated
- [ ] Path traversal prevented on file operations

## Authentication
- [ ] JWT tokens expire after 24 hours
- [ ] API keys stored in environment variables
- [ ] Passwords hashed with bcrypt or argon2`
}]
}]
}, {
 id: 'commands',
label: 'commands/',
type: 'folder',
icon: 'folder',
color: '#788C5D',
oneLiner: <>Single-file prompts invoked with
<C>/name</C></>,
note: commandsNote,
when: <>User types
<C>/command-name</C></>,
description: <>A file at
<C>commands/[Link]</C> creates
<C>/deploy</C> the same way a skill at
<C>skills/deploy/[Link]</C> does, and both can
be auto-invoked by Claude. Skills use a directory
with [Link], letting you bundle reference docs,
templates, or scripts alongside the prompt.</>,
tips: [<>Use <C>$ARGUMENTS</C> in the file
to accept parameters: <C>/fix-issue 123</C></>, 'If a
skill and command share a name, the skill takes
precedence', 'New commands should usually be
skills instead; commands remain supported'],
docsLink: '/en/skills',
children: [{
id: 'cmd-example',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#788C5D',
Manuel Navarro Hidalgo.
badge: 'committed',
oneLiner: <>Invoked as <C>/fix-issue
&lt;number&gt;</C></>,
note: commandsNote,
description: [<>An example command for
fixing a GitHub issue. Type <C>/fix-issue 123</C>
and the <C>!`...`</C> line runs <C>gh issue view
123</C> in your shell, injecting the output into the
prompt before Claude sees it.</>,
<><C>$ARGUMENTS</C> substitutes whatever you
typed after the command name. For positional
access, use <C>$0</C> <C>$1</C> and so on.</>],
example: `---
argument-hint: <issue-number>
---

!\`gh issue view $ARGUMENTS\`

Investigate and fix the issue above.

1. Trace the bug to its root cause

2. Implement the fix
3. Write or update tests
4. Summarize what you changed and why`
}]
}, {
id: 'output-styles',
label: 'output-styles/',
type: 'folder',
 icon: 'folder',
color: '#5AA7A7',
oneLiner: 'Project-scoped output styles, if
your team shares any',
when: 'Applied at session start when selected
via the outputStyle setting',
description: <>Output styles are usually
personal, so most live in
<C>~/.claude/output-styles/</C>. Put one here if
your team shares a style, like a review mode
everyone uses. See <A
href="#ce-global-output-styles">the Global tab</A>
for the full explanation and example.</>,
docsLink: '/en/output-styles',
children: []
}, {
id: 'agents',
label: 'agents/',
type: 'folder',
icon: 'folder',
color: '#C46686',
oneLiner: 'Specialized subagents with their
own context window',
when: 'Runs in its own context window when
you or Claude invoke it',
description: 'Each markdown file defines a
subagent with its own system prompt, tool access,
and optionally its own model. Subagents run in a
fresh context window, keeping the main
Manuel Navarro Hidalgo.
conversation clean. Useful for parallel work or
isolated tasks.',
tips: ['Each agent gets a fresh context window,
separate from your main session', <>Restrict tool
access per agent with the <C>tools:</C> frontmatter
field</>, 'Type @ and pick an agent from the
autocomplete to delegate directly'],
docsLink: '/en/sub-agents',
children: [{
id: 'agent-reviewer',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#C46686',
badge: 'committed',
oneLiner: 'Subagent for isolated code
review',
when: 'Claude spawns it for review tasks, or
you @-mention it from the autocomplete',
description: <>An example subagent
restricted to read-only tools. The
<C>description</C> frontmatter tells Claude when to
delegate to it automatically; <C>tools:</C> limits it
to Read, Grep, and Glob so it can inspect code but
never edit. The body becomes the subagent's
system prompt.</>,
example: `---
name: code-reviewer
description: Reviews code for correctness, security,
and maintainability
tools: Read, Grep, Glob
---

You are a senior code reviewer. Review for:

1. Correctness: logic errors, edge cases, null

handling
2. Security: injection, auth bypass, data exposure
3. Maintainability: naming, complexity, duplication

Every finding must include a concrete fix.`

}]
}, {
id: 'workflows',
label: 'workflows/',
type: 'folder',
icon: 'folder',
color: '#C46686',
oneLiner: 'Dynamic workflow scripts that
orchestrate many subagents',
when: 'Loaded at startup; each file becomes a
/<name> command',
description: <>Each <C>.js</C> file is a <A
href="/en/workflows">dynamic workflow</A>: a
script the runtime executes to spawn and coordinate
many subagents. Workflows are written by Claude
Manuel Navarro Hidalgo.
and saved here from <C>/workflows</C> rather than
authored from scratch.</>,
tips: [<>Save a run from <C>/workflows</C>
with <C>s</C> to create one of these</>, <>A project
workflow takes precedence over a personal one in
<C>~/.claude/workflows/</C> with the same
name</>],
docsLink: '/en/workflows'
}, {
id: 'agent-memory',
label: 'agent-memory/',
type: 'folder',
icon: 'folder',
color: '#C46686',
badge: 'committed',
autogen: true,
oneLiner: 'Subagent persistent memory,
separate from your main session auto memory',
when: 'First 200 lines (capped at 25KB) of
[Link] loaded into the subagent system
prompt when it runs',
description: <>Subagents with <C>memory:
project</C> in their frontmatter get a dedicated
memory directory here. This is distinct from your <A
href="/en/memory#auto-memory">main session
auto memory</A> at <C>~/.claude/projects/</C>:
each subagent reads and writes its own
[Link], not yours.</>,
 tips: [<>Only created for subagents that set
the <C>memory:</C> frontmatter field</>, <>This
directory holds project-scoped subagent memory,
meant to be shared with your team. To keep memory
out of version control use <C>memory: local</C>,
which writes to <C>.claude/agent-memory-local/</C>
instead. For cross-project memory use <C>memory:
user</C>, which writes to
<C>~/.claude/agent-memory/</C></>, <>The main
session auto memory is a different feature; see
<C>~/.claude/projects/</C> in the Global tab</>],
docsLink:
'/en/sub-agents#enable-persistent-memory',
children: [{
id: 'agent-memory-sub',
label: '<agent-name>/',
type: 'folder',
icon: 'folder',
color: '#C46686',
autogen: true,
children: [{
id: 'agent-memory-md',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#C46686',
badge: 'committed',
autogen: true,
Manuel Navarro Hidalgo.
oneLiner: 'The subagent writes and
maintains this file automatically',
when: 'Loaded into the subagent system
prompt when the subagent starts',
description: <>Works the same as your <A
href="/en/memory#auto-memory">main auto
memory</A>: the subagent creates and updates this
file itself. You do not write it. The subagent reads it
at the start of each task and writes back what it
learns.</>,
example: `# code-reviewer memory

## Patterns seen
- Project uses custom Result<T, E> type, not
exceptions
- Auth middleware expects Bearer token in
Authorization header
- Tests use factory functions in test/factories/

## Recurring issues
- Missing null checks on API responses (src/api/*)
- Unhandled promise rejections in background jobs`
}]
}]
}]
}]
},
global: {
label: '~/',
 children: [{
id: 'claude-json',
label: '.[Link]',
type: 'file',
icon: 'json',
color: 'var(--ce-text-3)',
badge: 'local',
oneLiner: 'App state and UI preferences',
when: <>Read at session start for your
preferences and MCP servers. Claude Code writes
back to it when you change settings in
<C>/config</C> or approve trust prompts</>,
description: <>Holds state that does not belong
in [Link]: theme, OAuth session, per-project
trust decisions, your personal MCP servers, and UI
toggles. Mostly managed through <C>/config</C>
rather than editing directly.</>,
tips: [<>IDE toggles like
<C>autoConnectIde</C> and
<C>externalEditorContext</C> live here, not in
[Link]</>, <>The <C>projects</C> key tracks
per-project state like trust-dialog acceptance and
last-session metrics. Permission rules you approve
in-session go to <C>.claude/[Link]</C>
instead</>, <>MCP servers here are yours only: user
scope applies across all projects, local scope is
per-project but not committed. Team-shared servers
go in <C>.[Link]</C> at the project root
instead</>],
Manuel Navarro Hidalgo.
example: `{
"autoConnectIde": true,
"externalEditorContext": true,
"mcpServers": {
"my-tools": {
"command": "npx",
"args": ["-y", "@example/mcp-server"]
}
}
}`,
docsLink: '/en/settings#global-config-settings'
}, {
id: 'global-dot-claude',
label: '.claude/',
type: 'folder',
icon: 'folder',
color: 'var(--ce-accent)',
oneLiner: 'Your personal configuration across
all projects',
description: 'The global counterpart to your
project .claude/ directory. Files here apply to every
project you work in and are never committed to any
repository.',
children: [{
id: 'global-claude-md',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#6A9BCC',
 badge: 'local',
oneLiner: 'Personal preferences across every
project',
when: 'Loaded at the start of every session, in
every project',
description: 'Your global instruction file.
Loaded alongside the project [Link] at
session start, so both are in context together. When
instructions conflict, project-level instructions take
priority. Keep this to preferences that apply
everywhere: response style, commit format,
personal conventions.',
tips: ['Keep it short since it loads into context
for every project, alongside that project\'s own
[Link]', 'Good for response style, commit
format, and personal conventions'],
example: `# Global preferences

- Keep explanations concise

- Use conventional commit format
- Show the terminal command to verify changes
- Prefer composition over inheritance`,
docsLink: '/en/memory'
}, {
id: 'global-settings',
label: '[Link]',
type: 'file',
icon: 'json',
color: 'var(--ce-text-3)',
Manuel Navarro Hidalgo.
badge: 'local',
oneLiner: 'Default settings for all projects',
when: 'Your defaults. Project and local
[Link] override any keys you also set there',
description: [<>Same keys as project
<C>[Link]</C>: permissions, hooks, model,
environment variables, and the rest. Put settings
here that you want in every project, like permissions
you always allow, a preferred model, or a
notification hook that runs regardless of which
project you're in.</>, <>Settings follow a precedence
order: project <C>[Link]</C> overrides any
matching keys you set here. This is different from
[Link], where global and project files are both
loaded into context rather than merged key by
key.</>],
example: `{
"permissions": {
"allow": [
"Bash(git log *)",
"Bash(git diff *)"
]
}
}`,
docsLink: '/en/settings'
}, {
id: 'keybindings',
label: '[Link]',
type: 'file',
 icon: 'json',
color: 'var(--ce-text-3)',
badge: 'local',
oneLiner: 'Custom keyboard shortcuts',
when: 'Read at session start and hot-reloaded
when you edit the file',
description: <>Rebind keyboard shortcuts in
the interactive CLI. Run <C>/keybindings</C> to
create or open this file with a schema reference.
Ctrl+C, Ctrl+D, Ctrl+M, and Caps Lock are reserved
and cannot be rebound.</>,
exampleIntro: <>This example binds
<C>Ctrl+E</C> to open your external editor and
unbinds <C>Ctrl+U</C> by setting it to <C>null</C>.
The <C>context</C> field scopes bindings to a
specific part of the CLI, here the main chat input.</>,
example: `{
"$schema":
"[Link]
[Link]",
"$docs":
"[Link]
"bindings": [
{
"context": "Chat",
"bindings": {
"ctrl+e": "chat:externalEditor",
"ctrl+u": null
}
Manuel Navarro Hidalgo.
}
]
}`,
docsLink: '/en/keybindings'
}, {
id: 'themes',
label: 'themes/',
type: 'folder',
icon: 'folder',
color: '#5AA7A7',
oneLiner: 'Custom color themes',
when: <>Read at session start and
hot-reloaded when files change. Listed in
<C>/theme</C></>,
description: <>Each <C>.json</C> file defines
a custom color theme: a built-in <C>base</C> preset
plus an <C>overrides</C> map of color tokens.
Create one interactively with <C>/theme</C> or write
the JSON by hand. Selecting a custom theme stores
<C>custom:&lt;slug&gt;</C> as your theme
preference.</>,
example: `{
"name": "Dracula",
"base": "dark",
"overrides": {
"claude": "#bd93f9",
"error": "#ff5555",
"success": "#50fa7b"
}
}`,
docsLink:
'/en/terminal-config#create-a-custom-theme',
children: []
}, {
id: 'global-projects',
label: 'projects/',
type: 'folder',
icon: 'folder',
color: '#E8A45C',
autogen: true,
oneLiner: "Auto memory: Claude's notes to
itself, per project",
when: '[Link] loaded at session start;
topic files read on demand',
description: 'Auto memory lets Claude
accumulate knowledge across sessions without you
writing anything. Claude saves notes as it works:
build commands, debugging insights, architecture
notes. Each project gets its own memory directory
keyed by the repository path.',
tips: [<>On by default. Toggle with
<C>/memory</C> or <C>autoMemoryEnabled</C> in
settings</>, '[Link] is the index loaded each
session. The first 200 lines, or 25KB, whichever
comes first, are read', 'Topic files like [Link]
are read on demand, not at startup', 'These are plain
markdown. Edit or delete them anytime'],
docsLink: '/en/memory#auto-memory',
Manuel Navarro Hidalgo.
children: [{
id: 'memory-dir',
label: '<project>/memory/',
type: 'folder',
icon: 'folder',
color: '#E8A45C',
autogen: true,
oneLiner: "Claude's accumulated knowledge
for one project",
children: [{
id: 'memory-md',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#E8A45C',
badge: 'local',
autogen: true,
oneLiner: 'Claude writes and maintains this
file automatically',
when: 'First 200 lines (capped at 25KB)
loaded at session start',
description: 'Claude creates and updates
this file as it works; you do not write it yourself. It
acts as an index that Claude reads at the start of
every session, pointing to topic files for detail. You
can edit or delete it, but Claude will keep updating
it.',
example: `# Memory Index
## Project
- [[Link]]([Link]): npm run
build (~45s), Vitest, dev server on 3001
- [[Link]]([Link]): API client
singleton, refresh-token auth

## Reference
- [[Link]]([Link]): auth token
rotation and DB connection troubleshooting`,
docsLink: '/en/memory'
}, {
id: 'memory-topic',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#E8A45C',
badge: 'local',
autogen: true,
oneLiner: 'Topic notes Claude writes when
[Link] gets long',
when: 'Claude reads this when a related
task comes up',
description: 'An example of a topic file
Claude creates when [Link] grows too long.
Claude picks the filename based on what it splits
out: [Link], [Link],
[Link], or similar. You never create
these yourself. Claude reads a topic file back only
when the current task relates to it.',
Manuel Navarro Hidalgo.
example: `---
name: Debugging patterns
description: Auth token rotation and database
connection troubleshooting for this project
type: reference
---

## Auth Token Issues

- Refresh token rotation: old token invalidated
immediately
- If 401 after refresh: check clock skew between
client and server

## Database Connection Drops

- Connection pool: max 10 in dev, 50 in prod
- Always check \`docker compose ps\` first`
}]
}]
}, {
id: 'global-rules',
label: 'rules/',
type: 'folder',
icon: 'folder',
color: '#9B7BC4',
oneLiner: 'User-level rules that apply to every
project',
when: <>Rules without <C>paths:</C> load at
session start. Rules with <C>paths:</C> load when a
matching file enters context</>,
 description: 'Same as project .claude/rules/
but applies everywhere. Use this for conventions
you want across all your work, like personal code
style or commit message format.',
docsLink:
'/en/memory#organize-rules-with-claude/rules/',
children: []
}, {
id: 'global-skills',
label: 'skills/',
type: 'folder',
icon: 'folder',
color: '#D4A843',
oneLiner: 'Personal skills available in every
project',
when: <>Invoked with <C>/skill-name</C> in
any project</>,
description: 'Skills you built for yourself that
work everywhere. Same structure as project skills:
each is a folder with [Link], scoped to your user
account instead of a single project.',
docsLink: '/en/skills',
children: []
}, {
id: 'global-commands',
label: 'commands/',
type: 'folder',
icon: 'folder',
color: '#788C5D',
Manuel Navarro Hidalgo.
oneLiner: 'Personal single-file commands
available in every project',
note: commandsNote,
when: <>User types <C>/command-name</C>
in any project</>,
description: 'Same as project commands/ but
scoped to your user account. Each markdown file
becomes a command available everywhere.',
docsLink: '/en/skills',
children: []
}, {
id: 'global-output-styles',
label: 'output-styles/',
type: 'folder',
icon: 'folder',
color: '#5AA7A7',
oneLiner: 'Custom system-prompt sections
that adjust how Claude works',
when: 'Applied at session start when selected
via the outputStyle setting',
description: [<>Each markdown file defines an
output style: a section appended to the system
prompt that, by default, also drops the built-in
software-engineering task instructions. Use this to
adapt Claude Code for uses beyond coding, or to
add teaching or review modes.</>, <>Select a
built-in or custom style with <C>/config</C> or the
<C>outputStyle</C> key in settings. Styles here are
available in every project; project-level styles with
the same name take precedence.</>],
tips: ['Built-in styles Explanatory and Learning
are included with Claude Code; custom styles go
here', <>Set <C>keep-coding-instructions: true</C>
in frontmatter to keep the default task instructions
alongside your additions</>, 'Changes take effect on
the next session since the system prompt is fixed at
startup for caching'],
docsLink: '/en/output-styles',
children: [{
id: 'output-style-example',
label: '[Link]',
type: 'file',
icon: 'md',
color: '#5AA7A7',
badge: 'local',
oneLiner: 'Example style that adds
explanations and leaves small changes for you',
when: <>Active when <C>outputStyle</C> in
settings is set to <C>teaching</C></>,
description: <>This style appends
instructions to the system prompt: Claude adds a
"Why this approach" note after each task and leaves
TODO(human) markers for changes under 10 lines
instead of writing them itself. Select it by setting
<C>outputStyle</C> to the filename without .md, or
to the <C>name</C> field if you set one in
frontmatter.</>,
Manuel Navarro Hidalgo.
example: `---
description: Explains reasoning and asks you to
implement small pieces
keep-coding-instructions: true
---

After completing each task, add a brief "Why this

approach" note
explaining the key design decision.

When a change is under 10 lines, ask the user to

implement it
themselves by leaving a TODO(human) marker
instead of writing it.`
}]
}, {
id: 'global-agents',
label: 'agents/',
type: 'folder',
icon: 'folder',
color: '#C46686',
oneLiner: 'Personal subagents available in
every project',
when: 'Claude delegates or you @-mention in
any project',
description: 'Subagents defined here are
available across all your projects. Same format as
project agents.',
docsLink: '/en/sub-agents',
 children: []
}, {
id: 'global-workflows',
label: 'workflows/',
type: 'folder',
icon: 'folder',
color: '#C46686',
oneLiner: 'Personal dynamic workflows
available in every project',
when: 'Loaded at startup; each file becomes a
/<name> command',
description: <>Workflow scripts saved here
are available across all your projects. A project
workflow with the same name in
<C>.claude/workflows/</C> takes precedence.</>,
docsLink: '/en/workflows',
children: []
}, {
id: 'global-agent-memory',
label: 'agent-memory/',
type: 'folder',
icon: 'folder',
color: '#C46686',
autogen: true,
oneLiner: <>Persistent memory for subagents
with <C>memory: user</C></>,
when: 'Loaded into the subagent system
prompt when the subagent starts',
Manuel Navarro Hidalgo.
description: <>Subagents with <C>memory:
user</C> in their frontmatter store knowledge here
that persists across all projects. For project-scoped
subagent memory, see
<C>.claude/agent-memory/</C> instead.</>,
docsLink:
'/en/sub-agents#enable-persistent-memory',
children: []
}]
}]
}
}), []);
const BADGE_STYLES = useMemo(() => ({
committed: {
bg: 'rgba(85,138,66,0.08)',
color: 'var(--ce-badge-committed)',
border: 'rgba(85,138,66,0.15)',
label: 'committed'
},
gitignored: {
bg: 'rgba(217,119,87,0.06)',
color: 'var(--ce-badge-gitignored)',
border: 'rgba(217,119,87,0.15)',
label: 'gitignored'
},
local: {
bg: 'rgba(115,114,108,0.06)',
color: 'var(--ce-badge-local)',
border: 'rgba(115,114,108,0.12)',
 label: 'local only'
},
autogen: {
bg: 'rgba(232,164,92,0.1)',
color: 'var(--ce-badge-autogen)',
border: 'rgba(232,164,92,0.2)',
label: 'Claude writes'
}
}), []);
const allNodes = useMemo(() => {
const flatten = (nodes, acc, path, parentId) => {
for (const node of nodes) {
const nextPath = [...path, [Link]];
acc[[Link]] = {
...node,
path: nextPath,
parentId
};
if ([Link]) flatten([Link], acc,
nextPath, [Link]);
}
return acc;
};
const project =
flatten(FILE_TREE.[Link], {},
[FILE_TREE.[Link]]);
const global = flatten(FILE_TREE.[Link],
{}, [FILE_TREE.[Link]]);
for (const id in project) project[id].root = 'project';
Manuel Navarro Hidalgo.
for (const id in global) global[id].root = 'global';
return {
...project,
...global
};
}, [FILE_TREE]);
const allFolderIds = useMemo(() =>
[Link](allNodes).filter(id => allNodes[id].type
=== 'folder'), [allNodes]);
const DEFAULT_EXPANDED = ['dot-claude', 'rules',
'skills', 'skill-review', 'commands', 'agents',
'agent-memory', 'agent-memory-sub',
'global-dot-claude', 'global-output-styles',
'global-projects', 'memory-dir'];
const [mounted, setMounted] = useState(false);
const [activeRoot, setActiveRoot] =
useState('project');
const [selectedId, setSelectedId] =
useState('claude-md');
const [expandedFolders, setExpandedFolders] =
useState(() => new Set(DEFAULT_EXPANDED));
const [forceMobile, setForceMobile] =
useState(false);
const [copiedId, setCopiedId] = useState(null);
const [isFullscreen, setIsFullscreen] =
useState(false);
const copyTimeoutRef = useRef(null);
const rootRef = useRef(null);
useEffect(() => {
 setMounted(true);
const applyHash = scroll => {
const hash = [Link](1);
if () return;
const id = [Link](3);
const node = allNodes[id];
if (!node) return;
setActiveRoot([Link]);
setSelectedId(id);
setExpandedFolders(new Set(allFolderIds));
if (scroll && [Link])
[Link]({
behavior: 'smooth',
block: 'start'
});
};
applyHash(false);
const onHashChange = () => applyHash(true);
const onFsChange = () =>
setIsFullscreen(!![Link]);
[Link]('hashchange',
onHashChange);
[Link]('fullscreenchange',
onFsChange);
return () => {
if ([Link])
clearTimeout([Link]);
[Link]('hashchange',
onHashChange);
Manuel Navarro Hidalgo.

[Link]('fullscreenchange',
onFsChange);
};
}, []);
useEffect(() => {
if (!mounted || ![Link]) return;
const hash = [Link](1);
if ([Link]('ce-') &&
allNodes[[Link](3)]) {
[Link]({
behavior: 'smooth',
block: 'start'
});
}
}, [mounted]);
if (!mounted) return null;
const selected = allNodes[selectedId];
const tree = FILE_TREE[activeRoot];
const isCopied = copiedId === [Link];
const toggleFolder = id => {
const next = new Set(expandedFolders);
[Link](id) ? [Link](id) : [Link](id);
setExpandedFolders(next);
};
const switchRoot = root => {
if (root === activeRoot) return;
setActiveRoot(root);
const firstId = FILE_TREE[root].children[0].id;
 setSelectedId(firstId);
try {
[Link](null, '', '#ce-' + firstId);
} catch (e) {}
};
const toggleFullscreen = () => {
if (![Link]) return;
if ([Link])
[Link](); else
[Link]().catch(() => {});
};
const selectNode = n => {
setSelectedId([Link]);
if ([Link] === 'folder' &&
) toggleFolder([Link]);
try {
[Link](null, '', '#ce-' + [Link]);
} catch (e) {}
};
const iconBtn = {
width: 28,
flexShrink: 0,
borderRadius: '6px',
border: 'none',
cursor: 'pointer',
background: 'transparent',
color: 'var(--ce-text-4)',
display: 'flex',
alignItems: 'center',
Manuel Navarro Hidalgo.
justifyContent: 'center'
};
const visibleFolderIds = [Link](id =>
allNodes[id].root === activeRoot);
const allExpanded = [Link](id =>
[Link](id));
const toggleAllFolders = () => {
const next = new Set(expandedFolders);
[Link](id => allExpanded ?
[Link](id) : [Link](id));
setExpandedFolders(next);
};
const onTreeKeyDown = e => {
if (!['ArrowDown', 'ArrowUp', 'ArrowRight',
'ArrowLeft'].includes([Link])) return;
const visible = [];
const walk = nodes => {
for (const n of nodes) {
[Link]([Link]);
if ([Link] && [Link]([Link]))
walk([Link]);
}
};
walk([Link]);
const i = [Link](selectedId);
if (i === -1) return;
[Link]();
if ([Link] === 'ArrowDown' && i < [Link] - 1)
selectNode(allNodes[visible[i + 1]]); else if ([Link]
=== 'ArrowUp' && i > 0)
selectNode(allNodes[visible[i - 1]]); else if ([Link] ===
'ArrowRight' && [Link] === 'folder') {
if ()
toggleFolder(selectedId); else if ([Link]
&& [Link])
selectNode(allNodes[[Link][0].id]);
} else if ([Link] === 'ArrowLeft') {
if ([Link] === 'folder' &&
[Link](selectedId))
toggleFolder(selectedId); else if ([Link])
selectNode(allNodes[[Link]]);
}
};
const copyExample = (id, text) => {
const done = () => {
setCopiedId(id);
if ([Link])
clearTimeout([Link]);
[Link] = setTimeout(() =>
setCopiedId(null), 2000);
};
const fallback = () => {
const ta = [Link]('textarea');
[Link] = text;
[Link] = 'fixed';
[Link] = '0';
[Link](ta);
[Link]();
Manuel Navarro Hidalgo.
try {
if ([Link]('copy')) done();
} catch (e) {}
[Link](ta);
};
if ([Link]) {
[Link](text).then(done,
fallback);
} else {
fallback();
}
};
const renderIcon = (icon, color, size) => {
const sz = size || 14;
if (icon === 'folder') {
return <svg width={sz} height={sz} viewBox="0 0
14 14" fill="none">
<path d="M1.5 3.5a1 1 0 0 1 1-1h2.6l1
1.2h5.4a1 1 0 0 1 1 1v5.8a1 1 0 0 1-1 1h-9a1 1 0 0
1-1-1V3.5z" fill={color} fillOpacity="0.15"
stroke={color} strokeWidth="1" />
</svg>;
}
if (icon === 'json') {
return <svg width={sz} height={sz} viewBox="0 0
14 14" fill="none">
<rect x="2" y="1.5" width="10" height="11"
rx="1.5" fill={color} fillOpacity="0.15" stroke={color}
strokeWidth="1" />
 <text x="7" y="9" font Size="6"
fontFamily="monospace" fill={color}
textAnchor="middle" fontWeight="700">{'{}'}</text>
</svg>;
}
return <svg width={sz} height={sz} viewBox="0 0
14 14" fill="none">
<rect x="2" y="1.5" width="10" height="11"
rx="1.5" fill={color} fillOpacity="0.15" stroke={color}
strokeWidth="1" />
<line x1="4.5" y1="5" x2="9.5" y2="5"
stroke={color} strokeWidth="1" />
<line x1="4.5" y1="7" x2="9.5" y2="7"
stroke={color} strokeWidth="1" />
<line x1="4.5" y1="9" x2="8" y2="9"
stroke={color} strokeWidth="1" />
</svg>;
};
const renderNode = (node, depth) => {
const isFolder = [Link] === 'folder';
const isExpanded =
[Link]([Link]);
const isSelected = selectedId === [Link];
return <div key={[Link]}>
<button role="treeitem" tabIndex={-1}
onClick={() => selectNode(node)}
aria-selected={isSelected} aria-expanded={isFolder
? isExpanded : undefined} style={{
display: 'flex',
Manuel Navarro Hidalgo.
alignItems: 'center',
gap: '5px',
width: '100%',
padding: `4px 8px 4px ${8 + depth * 16}px`,
background: isSelected ? 'var(--ce-accent-bg)' :
'transparent',
borderTop: 'none',
borderRight: 'none',
borderBottom: 'none',
borderLeft: isSelected ? '2px solid
var(--ce-accent)' : '2px solid transparent',
outline: 'none',
cursor: 'pointer',
textAlign: 'left',
fontFamily: 'var(--ce-mono)',
fontSize: '13.5px',
color: isSelected ? 'var(--ce-accent)' :
'var(--ce-text-2)',
fontWeight: isSelected ? 550 : 400,
transition: 'all 0.1s'
}}>
{isFolder ? <span onClick={e => {
[Link]();
toggleFolder([Link]);
}} style={{
fontSize: '14px',
color: 'var(--ce-text-4)',
width: '20px',
height: '20px',
 display: 'inline-flex',
alignItems: 'center',
justifyContent: 'center',
cursor: 'pointer',
borderRadius: '4px',
marginLeft: '-6px',
flexShrink: 0
}} onMouseEnter={e => {
[Link] =
'var(--ce-arrow-hover)';
[Link] = 'var(--ce-text-2)';
}} onMouseLeave={e => {
[Link] = 'transparent';
[Link] = 'var(--ce-text-4)';
}}>{isExpanded ? '▾' : '▸'}</span> : <span style={{
width: '14px',
flexShrink: 0
}} />}
{renderIcon([Link], [Link])}
<span style={{
flex: 1,
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap'
}}>{[Link]}</span>
{[Link] &&
BADGE_STYLES[[Link]] && <span
title={BADGE_STYLES[[Link]].label} style={{
width: 6,
Manuel Navarro Hidalgo.
height: 6,
borderRadius: '50%',
background:
BADGE_STYLES[[Link]].color,
flexShrink: 0,
opacity: 0.7
}} />}
</button>
{isFolder && isExpanded && [Link] &&
<div role="group">{[Link](child =>
renderNode(child, depth + 1))}</div>}
</div>;
};
return <>
<style>{`
.ce-root {
--ce-mono: var(--font-mono, ui-monospace,
monospace);
--ce-accent: #D97757;
--ce-accent-bg: rgba(217,119,87,0.06);
--ce-accent-border: rgba(217,119,87,0.12);
--ce-bg: #fff;
--ce-surface: #FAFAF7;
--ce-surface-hover: #F0EEE6;
--ce-border: #E8E6DC;
--ce-border-subtle: #F0EEE6;
--ce-text: #141413;
--ce-text-2: #5E5D59;
--ce-text-3: #73726C;
 --ce-text-4: #9C9A92;
--ce-text-5: #B8B6AE;
--ce-sep: #D1CFC5;
--ce-code-header: #F5F4ED;
--ce-code-bg: #1A1918;
--ce-arrow-hover: rgba(0,0,0,0.08);
--ce-badge-committed: #3d6b2e;
--ce-badge-gitignored: #b85c3a;
--ce-badge-local: #5e5d59;
--ce-badge-autogen: #b07520;
--ce-when-text: #4a7fb5;
}
.dark .ce-root {
--ce-bg: #1a1918;
--ce-surface: #232221;
--ce-surface-hover: #2e2d2b;
--ce-border: #3a3936;
--ce-border-subtle: #2e2d2b;
--ce-text: #e8e6dc;
--ce-text-2: #c4c2b8;
--ce-text-3: #9c9a92;
--ce-text-4: #73726c;
--ce-text-5: #5e5d59;
--ce-sep: #4a4946;
--ce-code-header: #2e2d2b;
--ce-code-bg: #0d0d0c;
--ce-arrow-hover: rgba(255,255,255,0.08);
--ce-badge-committed: #6fa85c;
--ce-badge-gitignored: #e08a60;
Manuel Navarro Hidalgo.
--ce-badge-local: #9c9a92;
--ce-badge-autogen: #e8a45c;
--ce-when-text: #8bb4e0;
}
.ce-mobile-fallback { display: none; border: 1px
solid rgba(0,0,0,0.1); background: rgba(0,0,0,0.03); }
.dark .ce-mobile-fallback { border-color:
rgba(255,255,255,0.15); background:
rgba(255,255,255,0.04); }
@media (max-width: 700px) {
.ce-root:not(.ce-force) { display: none
!important; }
.ce-mobile-fallback { display: block; }
}
`}</style>
{!forceMobile && <div
className="ce-mobile-fallback" style={{
padding: '14px 16px',
borderRadius: '8px',
fontSize: '14px'
}}>
The interactive explorer works best on a larger
screen. See the <a href="#file-reference" style={{
color: '#D97757'
}}>file reference table</a> below, or <button
onClick={() => setForceMobile(true)} style={{
border: 'none',
background: 'none',
padding: 0,
 color: '#D97757',
textDecoration: 'underline',
cursor: 'pointer',
font: 'inherit'
}}>show the explorer anyway</button>.
</div>}
<div ref={rootRef} className={forceMobile ?
'ce-root ce-force' : 'ce-root'} style={{
borderRadius: isFullscreen ? 0 : '12px',
border: '1px solid var(--ce-border)',
background: 'var(--ce-bg)',
display: 'flex',
alignItems: 'stretch',
overflow: 'hidden',
fontFamily: 'var(--font-sans, -apple-system,
sans-serif)',
...isFullscreen && ({
height: '100vh'
})
}}>
{}
<div style={{
width: 'min(240px, 35%)',
minWidth: '180px',
flexShrink: 0,
borderRight: '1px solid var(--ce-border-subtle)',
background: 'var(--ce-surface)',
display: 'flex',
flexDirection: 'column'
Manuel Navarro Hidalgo.
}}>
<div style={{
padding: '8px 8px 4px',
borderBottom: '1px solid var(--ce-border-subtle)',
display: 'flex',
gap: '4px'
}}>
{['project', 'global'].map(root => <button
key={root} onClick={() => switchRoot(root)} style={{
flex: 1,
padding: '6px 0',
borderRadius: '6px',
border: 'none',
cursor: 'pointer',
fontFamily: 'var(--ce-mono)',
fontSize: '11.5px',
background: activeRoot === root ?
'var(--ce-accent-bg)' : 'transparent',
color: activeRoot === root ? 'var(--ce-accent)' :
'var(--ce-text-4)',
fontWeight: activeRoot === root ? 600 : 430
}}>
{root === 'project' ? 'Project' : 'Global (~/)'}
</button>)}
<button onClick={toggleAllFolders}
title={allExpanded ? 'Collapse all' : 'Expand all'}
style={{
...iconBtn,
fontSize: 11
 }}>
{allExpanded ? '⊟' : '⊞'}
</button>
<button onClick={toggleFullscreen}
title={isFullscreen ? 'Exit fullscreen' : 'Fullscreen'}
style={{
...iconBtn,
fontSize: 13
}}>
{isFullscreen ? '⤡' : '⛶'}
</button>
</div>
<div role="tree" aria-label="Configuration files"
tabIndex={0} onKeyDown={onTreeKeyDown}
style={{
padding: '6px 0',
overflowY: 'auto',
flex: 1,
outline: 'none'
}}>
{[Link](node => renderNode(node,
0))}
</div>
</div>

{}
<div style={{
flex: 1,
minWidth: 0,
Manuel Navarro Hidalgo.
padding: '20px 24px',
minHeight: '400px',
overflowY: 'auto'
}}>
<span aria-live="polite" style={{
position: 'absolute',
width: 1,
height: 1,
overflow: 'hidden',
clip: 'rect(0 0 0 0)'
}}>{[Link]} selected</span>
{}
<div style={{
fontFamily: 'var(--ce-mono)',
fontSize: '11px',
color: 'var(--ce-text-4)',
marginBottom: '10px',
cursor: 'default'
}}>
{[Link]((seg, i) => <span
key={i}>
<span style={{
color: i === [Link] - 1 ?
'var(--ce-accent)' : 'var(--ce-text-4)'
}}>{[Link](/\/$/, '')}</span>
{i < [Link] - 1 && <span
style={{
color: 'var(--ce-sep)'
}}> / </span>}
 </span>)}
</div>

{}
<div style={{
display: 'flex',
alignItems: 'flex-start',
gap: '10px',
marginBottom: '10px'
}}>
<span style={{
flexShrink: 0,
display: 'flex'
}}>{renderIcon([Link], [Link],
24)}</span>
<div style={{
flex: 1,
minWidth: 0
}}>
<div style={{
fontSize: '22px',
fontWeight: 600,
color: 'var(--ce-text)',
letterSpacing: '-0.3px',
lineHeight: '26px'
}}>{[Link]}</div>
{[Link] && <div style={{
fontSize: '15px',
color: 'var(--ce-text-3)',
Manuel Navarro Hidalgo.
marginTop: '3px'
}}>{[Link]}</div>}
</div>
<div style={{
display: 'flex',
gap: '4px',
flexShrink: 0
}}>
{[[Link] && 'autogen',
[Link]].filter(Boolean).map(k => {
const s = BADGE_STYLES[k];
if (!s) return null;
return <span key={k} style={{
fontFamily: 'var(--ce-mono)',
fontSize: '10px',
fontWeight: 600,
textTransform: 'uppercase',
letterSpacing: '0.3px',
padding: '2px 6px',
borderRadius: '4px',
background: [Link],
color: [Link],
border: `0.5px solid ${[Link]}`
}}>{[Link]}</span>;
})}
</div>
</div>

{}
 {[Link] && <div style={{
padding: '10px 12px',
borderRadius: '8px',
marginBottom: '14px',
background: 'rgba(217,119,87,0.06)',
border: '1px solid rgba(217,119,87,0.2)',
borderLeft: '3px solid var(--ce-accent)',
fontSize: '15px',
color: 'var(--ce-text-2)',
lineHeight: 1.6
}}>
{[Link]}
</div>}

{}
{[Link] && <div style={{
padding: '8px 12px',
borderRadius: '6px',
background: 'rgba(106,155,204,0.06)',
border: '0.5px solid rgba(106,155,204,0.12)',
fontSize: '15px',
color: 'var(--ce-when-text)',
marginBottom: '16px'
}}>
<div style={{
fontSize: '10px',
fontWeight: 700,
textTransform: 'uppercase',
letterSpacing: '0.4px',
Manuel Navarro Hidalgo.
opacity: 0.65,
marginBottom: '3px'
}}>When it loads</div>
<div style={{
fontWeight: 500
}}>{[Link]}</div>
</div>}

{}
{[Link] && <div style={{
fontSize: '16px',
color: 'var(--ce-text-2)',
lineHeight: 1.65,
marginBottom: '16px'
}}>
{[Link]([Link]) ?
[Link]((para, i) => <div key={i}
style={{
marginBottom: i < [Link] - 1
? '12px' : 0
}}>{para}</div>) : [Link]}
</div>}

{}
{[Link] &&
[Link] > 0 && <div style={{
marginBottom: '16px'
}}>
<div style={{
 fontSize: '11px',
fontWeight: 700,
color: 'var(--ce-text-4)',
textTransform: 'uppercase',
letterSpacing: '0.4px',
marginBottom: '8px'
}}>Common keys</div>
{[Link]((item, i) => <div
key={i} style={{
display: 'flex',
gap: '7px',
fontSize: '15px',
color: 'var(--ce-text-2)',
lineHeight: 1.5,
marginBottom: '5px'
}}>
<span style={{
fontSize: '7px',
color: 'var(--ce-text-4)',
marginTop: '6px'
}}>●</span>
<span>{item}</span>
</div>)}
</div>}

{}
{[Link] && [Link] > 0 &&
<div style={{
padding: '12px 14px',
Manuel Navarro Hidalgo.
borderRadius: '8px',
background: 'var(--ce-surface)',
border: '1px solid var(--ce-border-subtle)',
marginBottom: '16px'
}}>
<div style={{
fontSize: '11px',
fontWeight: 700,
color: 'var(--ce-accent)',
textTransform: 'uppercase',
letterSpacing: '0.4px',
marginBottom: '6px'
}}>Tips</div>
{[Link]((tip, i) => <div key={i}
style={{
display: 'flex',
gap: '7px',
fontSize: '14.5px',
color: 'var(--ce-text-2)',
marginBottom: i < [Link] - 1 ? '5px' :
0
}}>
<span style={{
fontSize: '7px',
color: 'var(--ce-accent)',
marginTop: '6px'
}}>●</span>
<span>{tip}</span>
</div>)}
 </div>}

{}
{[Link] && <div style={{
marginBottom: '16px'
}}>
{[Link] && <div style={{
fontSize: '15px',
color: 'var(--ce-text-2)',
lineHeight: 1.6,
marginBottom: '10px'
}}>
{[Link]}
</div>}
<div style={{
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
padding: '6px 10px',
background: 'var(--ce-code-header)',
border: '1px solid var(--ce-border)',
borderRadius: '8px 8px 0 0'
}}>
<span style={{
fontFamily: 'var(--ce-mono)',
fontSize: '11px',
fontWeight: 600,
color: 'var(--ce-text-3)'
}}>{[Link]}</span>
Manuel Navarro Hidalgo.
<button onClick={() =>
copyExample([Link], [Link])}
style={{
padding: '3px 8px',
borderRadius: '4px',
fontSize: '11px',
fontWeight: 600,
cursor: 'pointer',
transition: 'all 0.15s',
background: isCopied ? 'rgba(85,138,66,0.08)' :
'var(--ce-code-header)',
border: isCopied ? '0.5px solid
rgba(85,138,66,0.2)' : '0.5px solid var(--ce-border)',
color: isCopied ? '#558A42' : 'var(--ce-text-3)'
}}>
{isCopied ? '✓ Copied' : 'Copy'}
</button>
</div>
<pre style={{
margin: 0,
padding: '12px 14px',
background: 'var(--ce-code-bg)',
color: '#E8E6DC',
fontFamily: 'var(--ce-mono)',
fontSize: '13px',
lineHeight: 1.65,
borderRadius: '0 0 8px 8px',
overflowX: 'auto',
whiteSpace: 'pre'
 }}>{[Link]}</pre>
</div>}

{}
{[Link] && <a
href={[Link]} style={{
display: 'inline-flex',
padding: '5px 12px',
borderRadius: '6px',
background: 'var(--ce-accent-bg)',
border: '1px solid var(--ce-accent-border)',
color: 'var(--ce-accent)',
fontSize: '12px',
fontWeight: 600,
textDecoration: 'none'
}}>Full docs →</a>}

{}
{[Link] &&
[Link] > 0 && <div style={{
marginTop: '20px'
}}>
<div style={{
fontSize: '11px',
fontWeight: 700,
color: 'var(--ce-text-4)',
textTransform: 'uppercase',
letterSpacing: '0.4px',
marginBottom: '8px'
Manuel Navarro Hidalgo.
}}>Contents</div>
<div style={{
display: 'flex',
flexDirection: 'column',
gap: '4px'
}}>
{[Link](child => <button
key={[Link]} onClick={() => selectNode(child)}
style={{
display: 'flex',
alignItems: 'center',
gap: '8px',
padding: '6px 8px',
width: '100%',
background: 'var(--ce-surface)',
borderRadius: '6px',
border: 'none',
cursor: 'pointer',
textAlign: 'left',
transition: 'background 0.1s'
}} onMouseEnter={e =>
[Link] =
'var(--ce-surface-hover)'} onMouseLeave={e =>
[Link] =
'var(--ce-surface)'}>
{renderIcon([Link], [Link], 13)}
<span style={{
fontFamily: 'var(--ce-mono)',
fontSize: '12px',
 color: 'var(--ce-text-2)'
}}>{[Link]}</span>
{[Link] && <span style={{
fontSize: '11px',
color: 'var(--ce-text-4)',
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap'
}}>{[Link]}</span>}
</button>)}
</div>
</div>}
</div>
</div>
</>;
};

Claude Code lee instrucciones, configuración, skills,

subagents y memoria desde su directorio de
proyecto y desde `~/.claude` en su directorio de
inicio. Confirme archivos de proyecto en git para
compartirlos con su equipo; los archivos en
`~/.claude` son configuración personal que se aplica
en todos sus proyectos.

En Windows, `~/.claude` se resuelve a

`%USERPROFILE%\.claude`. Si establece
[`CLAUDE_CONFIG_DIR`](/es/env-vars), cada ruta
Manuel Navarro Hidalgo.
`~/.claude` en esta página vive bajo ese directorio en
su lugar.

La mayoría de los usuarios solo editan

`[Link]` y `[Link]`. El resto del
directorio es opcional: agregue skills, rules o
subagents según sea necesario.

<h2 id="explore-the-directory">
Explorar el directorio
</h2>

Haga clic en los archivos del árbol para ver qué

hace cada uno, cuándo se carga y un ejemplo.

<ClaudeExplorer />

<h2 id="what’s-not-shown">
Lo que no se muestra
</h2>

El explorador cubre archivos que usted crea y edita.

Algunos archivos relacionados viven en otros
lugares:

| Archivo | Ubicación |
Propósito
|
| ----------------------- | ------------------------------------ |
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------
------------------- |
| `[Link]` | Nivel del sistema, varía
según el SO | Configuración impuesta por la
empresa que no puede anular. Consulte
[configuración administrada por
servidor](/es/server-managed-settings).
|
| `[Link]` | Raíz del proyecto
| Sus preferencias privadas para este proyecto,
cargadas junto con [Link]. Créelo
manualmente y agréguelo a `.gitignore`.
|
| Plugins instalados | `~/.claude/plugins`
| Mercados clonados, versiones de plugins
instaladas y datos por plugin, administrados por
comandos `claude plugin`. Las versiones huérfanas
se eliminan 7 días después de una actualización o
desinstalación de plugin. Consulte [almacenamiento
en caché de
plugins](/es/plugins-reference#plugin-caching-and-fi
le-resolution). |

`~/.claude` también contiene datos que Claude Code

escribe mientras trabaja: transcripciones, historial
Manuel Navarro Hidalgo.
de prompts, instantáneas de archivos, cachés y
registros. Consulte [datos de
aplicación](#application-data) a continuación.

<h2 id="choose-the-right-file">
Elegir el archivo correcto
</h2>

Diferentes tipos de personalización viven en

diferentes archivos. Use esta tabla para encontrar
dónde pertenece un cambio.

| Usted quiere | Editar

| Alcance | Referencia |
| :------------------------------------------------------------- |
:-------------------------------------- | :---------------- |
:------------------------------------------------- |
| Dar a Claude contexto del proyecto y
convenciones | `[Link]`
| proyecto o global | [Memory](/es/memory)
|
| Permitir o bloquear llamadas de herramientas
específicas | `[Link]` `permissions` o
`hooks` | proyecto o global |
[Permissions](/es/permissions), [Hooks](/es/hooks) |
| Ejecutar un script antes o después de llamadas de
herramientas | `[Link]` `hooks` |
proyecto o global | [Hooks](/es/hooks)
|
| Establecer variables de entorno para la sesión
| `[Link]` `env` | proyecto o global |
[Settings](/es/settings#available-settings) |
| Mantener anulaciones personales fuera de git
| `[Link]` | solo proyecto |
[Settings scopes](/es/settings#settings-files) |
| Agregar un prompt o capacidad que invoque con
`/name` | `skills/<name>/[Link]` |
proyecto o global | [Skills](/es/skills)
|
| Definir un subagent especializado con sus propias
herramientas | `agents/*.md` |
proyecto o global | [Subagents](/es/sub-agents)
|
| Orquestar muchos subagents desde un script
| `workflows/*.js` | proyecto o global |
[Dynamic workflows](/es/workflows) |
| Conectar herramientas externas sobre MCP
| `.[Link]` | solo proyecto |
[MCP](/es/mcp) |
| Cambiar cómo Claude formatea respuestas
| `output-styles/*.md` | proyecto o global |
[Output styles](/es/output-styles) |

<h2 id="file-reference">
Referencia de archivos
</h2>
Manuel Navarro Hidalgo.
Esta tabla enumera todos los archivos que cubre el
explorador. Los archivos de alcance de proyecto
viven en su repositorio bajo `.claude/` (o en la raíz
para `[Link]`, `.[Link]` y
`.worktreeinclude`). Los archivos de alcance global
viven en `~/.claude/` y se aplican en todos los
proyectos.

<Note>
Varias cosas pueden anular lo que pone en estos
archivos:

* [Configuración
administrada](/es/server-managed-settings)
implementada por su organización tiene prioridad
sobre todo
* Las banderas CLI como `--permission-mode` o
`--settings` anulan `[Link]` para esa sesión
* Algunas variables de entorno tienen prioridad
sobre su configuración equivalente, pero esto varía:
consulte la [referencia de variables de
entorno](/es/env-vars) para cada una

Consulte [precedencia de
configuración](/es/settings#settings-precedence)
para el orden completo.
</Note>
Haga clic en un nombre de archivo para abrir ese
nodo en el explorador anterior.

| Archivo | Alcance |
Confirmar | Qué hace
| Referencia |
| --------------------------------------------------- | ----------------- |
--------- |
---------------------------------------------------------------------------
--------------------------------------------------------------- |
--------------------------------------------------------------- |
| [`[Link]`](#ce-claude-md) |
Proyecto y global | ✓ | Instrucciones cargadas
cada sesión
| [Memory](/es/memory) |
| [`rules/*.md`](#ce-rules) | Proyecto y
global | ✓ | Instrucciones con alcance de tema,
opcionalmente con puerta de ruta
|
[Rules](/es/memory#organize-rules-with-claude/rule
s/) |
| [`[Link]`](#ce-settings-json) |
Proyecto y global | ✓ | Permisos, hooks,
variables de entorno, valores predeterminados de
modelo |
[Settings](/es/settings) |
| [`[Link]`](#ce-settings-local-json) |
Solo proyecto | | Sus anulaciones
personales, auto-gitignored
Manuel Navarro Hidalgo.
| [Settings scopes](/es/settings#settings-files)
|
| [`.[Link]`](#ce-mcp-json) | Solo
proyecto | ✓ | Servidores MCP compartidos
por el equipo
| [MCP scopes](/es/mcp#mcp-installation-scopes)
|
| [`.worktreeinclude`](#ce-worktreeinclude) |
Solo proyecto | ✓ | Archivos ignorados por
Git para copiar en nuevos worktrees
|
[Worktrees](/es/worktrees#copy-gitignored-files-into
-worktrees) |
| [`skills/<name>/[Link]`](#ce-skills) |
Proyecto y global | ✓ | Prompts reutilizables
invocados con `/name` o auto-invocados
| [Skills](/es/skills) |
| [`commands/*.md`](#ce-commands) |
Proyecto y global | ✓ | Prompts de archivo
único; mismo mecanismo que skills
| [Skills](/es/skills) |
| [`output-styles/*.md`](#ce-output-styles) |
Proyecto y global | ✓ | Secciones de prompt del
sistema personalizadas
| [Output styles](/es/output-styles) |
| [`agents/*.md`](#ce-agents) |
Proyecto y global | ✓ | Definiciones de
subagents con su propio prompt y herramientas
| [Subagents](/es/sub-agents) |
| [`workflows/*.js`](#ce-workflows) |
Proyecto y global | ✓ | Scripts de flujo de
trabajo dinámico escritos por Claude y guardados
desde `/workflows`; cada archivo se convierte en un
comando `/<name>` | [Dynamic
workflows](/es/workflows) |
| [`agent-memory/<name>/`](#ce-agent-memory)
| Proyecto y global | ✓ | Memoria persistente
para subagents
| [Persistent
memory](/es/sub-agents#enable-persistent-memory)
|
| [`~/.[Link]`](#ce-claude-json) | Solo
global | | Estado de la aplicación, OAuth,
alternancias de UI, servidores MCP personales
| [Global config](/es/settings#global-config-settings)
|
| [`projects/<project>/memory/`](#ce-global-projects)
| Solo global | | Auto memory: notas de
Claude para sí mismo entre sesiones
| [Auto memory](/es/memory#auto-memory)
|
| [`[Link]`](#ce-keybindings) |
Solo global | | Atajos de teclado
personalizados
| [Keybindings](/es/keybindings)
|
| [`themes/*.json`](#ce-themes) | Solo
global | | Temas de color personalizados
Manuel Navarro Hidalgo.
| [Custom
themes](/es/terminal-config#create-a-custom-theme)
|

<h2 id="troubleshoot-configuration">
Solucionar problemas de configuración
</h2>

Si una configuración, hook o archivo no está

surtiendo efecto, consulte [Depurar su
configuración](/es/debug-your-config) para los
comandos de inspección y una tabla de búsqueda
por síntoma.

<h2 id="application-data">
Datos de aplicación
</h2>

Más allá de la configuración que usted crea,

`~/.claude` contiene datos que Claude Code escribe
durante las sesiones. Estos archivos son texto sin
formato. Cualquier cosa que pase a través de una
herramienta aterriza en una transcripción en disco:
contenidos de archivos, salida de comandos, texto
pegado.

<h3 id="cleaned-up-automatically">
Limpiados automáticamente
</h3>
Los archivos en las rutas a continuación se eliminan
al inicio una vez que tienen más de
[`cleanupPeriodDays`](/es/settings#available-setting
s). El valor predeterminado es 30 días.

| Ruta bajo `~/.claude/` | Contenidos

|
| -------------------------------------------- |
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---- |
| `projects/<project>/<session>.jsonl` |
Transcripción de conversación completa: cada
mensaje, llamada de herramienta y resultado de
herramienta |
| `projects/<project>/<session>/subagents/` |
Transcripciones de conversación de
[Subagent](/es/sub-agents), eliminadas con la
transcripción de sesión principal cuando vence
|
| `projects/<project>/<session>/tool-results/` |
Salidas de herramientas grandes derramadas en
archivos separados
|
| `file-history/<session>/` | Instantáneas
previas a la edición de archivos que Claude cambió,
utilizadas para [restauración de
checkpoint](/es/checkpointing) |
Manuel Navarro Hidalgo.
| `plans/` | Archivos de plan
escritos durante [plan
mode](/es/permission-modes#analyze-before-you-ed
it-with-plan-mode) |
| `debug/` | Registros de
depuración por sesión, escritos solo cuando
comienza con `--debug` o ejecuta `/debug`
|
| `paste-cache/`, `image-cache/` | Contenidos
de pastes grandes e imágenes adjuntas
|
| `session-env/` | Metadatos de
entorno por sesión
|
| `tasks/` | Listas de tareas por
sesión escritas por las herramientas de tareas
|
| `shell-snapshots/` | Entorno de shell
capturado utilizado por la herramienta Bash. Se
elimina al salir correctamente. El barrido borra
cualquiera dejado después de un bloqueo. |
| `backups/` | Copias con marca
de tiempo de `~/.[Link]` tomadas antes de
migraciones de configuración
|
| `feedback-bundles/` | Archivos de
transcripción redactados escritos por `/feedback` en
proveedores de terceros, para enviar a su equipo de
cuenta de Anthropic |
| `todos/`, `statsig/`, `logs/` | Directorios
heredados de versiones anteriores. Ya no se
escriben. El barrido elimina su contenido y luego el
directorio vacío. |

<h3 id="kept-until-you-delete-them">
Mantenidos hasta que los elimine
</h3>

Las siguientes rutas no están cubiertas por la

limpieza automática y persisten indefinidamente.

| Ruta bajo `~/.claude/` | Contenidos

|
| ---------------------- |
---------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------- |
| `[Link]` | Cada prompt que ha escrito,
con marca de tiempo y ruta del proyecto. Utilizado
para recuperación de flecha hacia arriba.
|
| `[Link]` | Conteos de tokens y costos
agregados mostrados por `/usage`
|
| `[Link]` | Copia en caché de
[configuración administrada por
servidor](/es/server-managed-settings) para su
Manuel Navarro Hidalgo.
organización. Solo presente cuando su organización
las ha configurado. Se actualiza en cada inicio. |

Otros archivos de caché pequeños y archivos de

bloqueo aparecen dependiendo de qué
características use y son seguros de eliminar.

<h3 id="plaintext-storage">
Almacenamiento de texto sin formato
</h3>

Las transcripciones e historial no están encriptados

en reposo. Los permisos de archivo del SO son la
única protección. Si una herramienta lee un archivo
`.env` o un comando imprime una credencial, ese
valor se escribe en
`projects/<project>/<session>.jsonl`. Para reducir la
exposición:

* Reduzca `cleanupPeriodDays` para acortar cuánto

tiempo se mantienen las transcripciones
* Establezca la variable de entorno
[`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/es/en
v-vars) para omitir la escritura de transcripciones e
historial de prompts en cualquier modo. En modo
no interactivo, puede pasar
`--no-session-persistence` junto con `-p`, o
establecer `persistSession: false` en el Agent SDK.
* Use [reglas de permisos](/es/permissions) para
denegar lecturas de archivos de credenciales

<h3 id="clear-local-data">
Borrar datos locales
</h3>

Ejecute `claude project purge` para eliminar el

estado que Claude Code mantiene para un proyecto.
El comando requiere Claude Code v2.1.124 o
posterior. Elimina:

* Transcripciones y memoria automática bajo

`projects/`
* Entradas por sesión de `tasks/`, `debug/` y
`file-history/`
* Líneas de prompt coincidentes en `[Link]`
* La entrada del proyecto en `~/.[Link]`

El comando imprime el plan de eliminación

completo y solicita confirmación antes de eliminar
cualquier cosa.

Obtenga una vista previa del plan sin eliminar nada:

```bash theme={null}
claude project purge ~/work/my-repo --dry-run
```
Manuel Navarro Hidalgo.
Elimine con un único mensaje de confirmación:

```bash theme={null}
claude project purge ~/work/my-repo
```

Omita la ruta para elegir un proyecto de una lista

interactiva.

Omita el mensaje de confirmación para usar en

scripts:

```bash theme={null}
claude project purge ~/work/my-repo --yes
```

Pase `--all` en lugar de una ruta para purgar el

estado de cada proyecto a la vez, lo que elimina
`[Link]` directamente en lugar de filtrarlo.
Pase `-i` para recorrer el plan de eliminación un
elemento a la vez.

El comando deja `shell-snapshots/` y `backups/`

solos porque no están limitados al proyecto, y
advierte sobre ellos en la salida del plan. Sale con
estado 1 si ningún estado coincide con la ruta dada.

También puede eliminar cualquiera de las rutas de

datos de aplicación anteriores manualmente. Las
nuevas sesiones no se ven afectadas. La tabla a
continuación muestra qué pierde para sesiones
pasadas.

| Eliminar
| Pierde |
|
---------------------------------------------------------------------------
---------------------------------------------------------------------------
-------------------------------------- |
--------------------------------------------------------------- |
| `~/.claude/projects/`
| Reanudar, continuar y rebobinar para sesiones
pasadas |
| `~/.claude/[Link]`
| Recuperación de prompt de flecha hacia arriba
|
| `~/.claude/file-history/`
| Restauración de checkpoint para sesiones
pasadas |
| `~/.claude/[Link]`
| Totales históricos mostrados por `/usage`
|
| `~/.claude/[Link]`
| Nada. Se vuelve a obtener en el próximo inicio.
|
| `~/.claude/debug/`, `~/.claude/plans/`,
`~/.claude/paste-cache/`, `~/.claude/image-cache/`,
`~/.claude/session-env/`, `~/.claude/tasks/`,
Manuel Navarro Hidalgo.
`~/.claude/shell-snapshots/`, `~/.claude/backups/` |
Nada orientado al usuario |
| `~/.claude/todos/`, `~/.claude/statsig/`,
`~/.claude/logs/`
| Nada. Directorios heredados no escritos por
versiones actuales. |

No elimine `~/.[Link]`, `~/.claude/[Link]`

o `~/.claude/plugins/`: esos contienen su
autenticación, preferencias y plugins instalados.

<h2 id="related-resources">
Recursos relacionados
</h2>

* [Manage Claude's memory](/es/memory): escriba y

organice [Link], rules y auto memory
* [Configure settings](/es/settings): establezca
permisos, hooks, variables de entorno y valores
predeterminados de modelo
* [Create skills](/es/skills): construya prompts y
flujos de trabajo reutilizables
* [Configure subagents](/es/sub-agents): defina
agentes especializados con su propio contexto

Explorar la ventana de contexto

> Una simulación interactiva de cómo se llena la
ventana de contexto de Claude Code durante una
sesión. Vea qué se carga automáticamente, cuánto
cuesta cada lectura de archivo y cuándo se activan
las reglas y hooks.

export const ContextWindow = () => {

const MAX = 200000;
const STARTUP_END = 0.2;
{}
const EVENTS = useMemo(() => [{}, {
t: 0.015,
kind: 'auto',
label: 'System prompt',
tokens: 4200,
color: '#6B6964',
vis: 'hidden',
desc: 'Core instructions for behavior, tool use,
and response formatting. Always loaded first. You
never see it.',
link: null
}, {
t: 0.035,
kind: 'auto',
label: 'Auto memory ([Link])',
tokens: 680,
color: '#E8A45C',
vis: 'hidden',
Manuel Navarro Hidalgo.
desc: "Claude's notes to itself from previous
sessions: build commands it learned, patterns it
noticed, mistakes to avoid. The first 200 lines or
25KB, whichever comes first, are loaded into the
conversation context.",
link: '/en/memory#auto-memory'
}, {
t: 0.06,
kind: 'auto',
label: 'Environment info',
tokens: 280,
color: '#6B6964',
vis: 'hidden',
desc: 'Working directory, platform, shell, OS
version, and whether this is a git repo. Git branch,
status, and recent commits load as a separate block
at the very end of the system prompt.',
link: null
}, {
t: 0.08,
kind: 'auto',
label: 'MCP tools (deferred)',
tokens: 120,
color: '#9B7BC4',
vis: 'hidden',
desc: 'MCP tool names listed so Claude knows
what is available. By default, full schemas stay
deferred and Claude loads specific ones on demand
via tool search when a task needs them. Set
`ENABLE_TOOL_SEARCH=auto` to load schemas
upfront when they fit within 10% of the context
window, or `ENABLE_TOOL_SEARCH=false` to load
everything.',
link: '/en/mcp#scale-with-mcp-tool-search'
}, {
t: 0.1,
kind: 'auto',
label: 'Skill descriptions',
tokens: 450,
color: '#D4A843',
vis: 'hidden',
noSurviveCompact: true,
desc: 'One-line descriptions of available skills so
Claude knows what it can invoke. Full skill content
loads only when Claude actually uses one. Skills
with `disable-model-invocation: true` are not in this
list. They stay completely out of context until you
invoke them with `/name`. Unlike the rest of the
startup content, this listing is not re-injected after
`/compact`. Only skills you actually invoked get
preserved.',
link: '/en/skills'
}, {
t: 0.12,
kind: 'auto',
label: '~/.claude/[Link]',
tokens: 320,
color: '#6A9BCC',
Manuel Navarro Hidalgo.
vis: 'hidden',
desc: 'Your global preferences. Applies to every
project. Loaded alongside project instructions at the
start of every conversation.',
link:
'/en/memory#choose-where-to-put-claude-md-files'
}, {
t: 0.14,
kind: 'auto',
label: 'Project [Link]',
tokens: 1800,
color: '#6A9BCC',
vis: 'hidden',
desc: 'Project conventions, build commands,
architecture notes. The most important file you can
create. Lives in your project root, so your whole
team gets the same instructions.',
tip: 'Keep it under 200 lines. Move reference
content to skills or path-scoped rules so it only
loads when needed.',
link: '/en/memory'
}, {}, {
t: 0.22,
kind: 'user',
label: 'Your prompt',
tokens: 45,
color: '#558A42',
vis: 'full',
 desc: '"Fix the auth bug where users get 401 after
token refresh"',
link: null
}, {}, {
t: 0.28,
kind: 'claude',
label: 'Read src/api/[Link]',
tokens: 2400,
color: '#8A8880',
vis: 'brief',
desc: 'Main auth file. You see "Read [Link]" in
your terminal, but the 2,400 tokens of file content
only Claude sees.',
tip: 'File reads dominate context usage. Be
specific in prompts ("fix the bug in [Link]") so
Claude reads fewer files. For research-heavy tasks,
use a subagent.',
link: null
}, {
t: 0.32,
kind: 'claude',
label: 'Read src/lib/[Link]',
tokens: 1100,
color: '#8A8880',
vis: 'brief',
desc: 'Following imports to the token module.
Shown as a one-liner in your terminal.',
link: null
}, {
Manuel Navarro Hidalgo.
t: 0.35,
kind: 'auto',
label: 'Rule: [Link]',
tokens: 380,
color: '#4A9B8E',
vis: 'brief',
desc: 'This rule in `.claude/rules/` has a `paths:`
pattern matching `src/api/**`. It loaded automatically
when Claude read a file in that directory. You see
"Loaded .claude/rules/[Link]" in your
terminal, but not the rule content.',
link: '/en/memory#path-specific-rules'
}, {
t: 0.38,
kind: 'claude',
label: 'Read [Link]',
tokens: 1800,
color: '#8A8880',
vis: 'brief',
desc: 'Tracing the auth flow deeper.',
link: null
}, {
t: 0.41,
kind: 'claude',
label: 'Read [Link]',
tokens: 1600,
color: '#8A8880',
vis: 'brief',
 desc: 'Checking existing tests for expected
behavior.',
link: null
}, {
t: 0.44,
kind: 'auto',
label: 'Rule: [Link]',
tokens: 290,
color: '#4A9B8E',
vis: 'brief',
desc: 'Another path-scoped rule, this one
matching `*.[Link]` files. Triggered when Claude
read [Link]. Shown as a one-line "Loaded"
notice.',
link: '/en/memory#path-specific-rules'
}, {
t: 0.47,
kind: 'claude',
label: 'grep "refreshToken"',
tokens: 600,
color: '#A09E96',
vis: 'brief',
desc: 'Search results across the codebase. You
see the command ran, not the full output.',
link: null
}, {}, {
t: 0.53,
kind: 'claude',
label: "Claude's analysis",
Manuel Navarro Hidalgo.
tokens: 800,
color: '#D97757',
vis: 'full',
desc: 'Explains the bug: token invalidated too
early in the rotation. This text appears in your
terminal.',
link: null
}, {
t: 0.57,
kind: 'claude',
label: 'Edit [Link]',
tokens: 400,
color: '#D97757',
vis: 'full',
desc: 'Fixes the token rotation order. The diff
appears in your terminal.',
link: null
}, {
t: 0.59,
kind: 'hook',
label: 'Hook: prettier',
tokens: 120,
color: '#B8860B',
vis: 'hidden',
desc: 'A PostToolUse hook in `[Link]` runs
prettier after every file edit and reports back via
`[Link]`. That field
enters Claude\'s context. Plain stdout on exit 0 does
not. It is written to the debug log only.',
 tip: 'Output JSON with `additionalContext` to send
info to Claude. For PostToolUse hooks, exit code 2
surfaces stderr as an error but cannot block since
the tool already ran. Keep output concise since it
enters context without truncation.',
link: '/en/hooks-guide'
}, {
t: 0.62,
kind: 'claude',
label: 'Edit [Link]',
tokens: 600,
color: '#D97757',
vis: 'full',
desc: 'Adds a regression test for the fix. The diff
appears in your terminal.',
link: null
}, {
t: 0.64,
kind: 'hook',
label: 'Hook: prettier',
tokens: 100,
color: '#B8860B',
vis: 'hidden',
desc: 'The same hook fires again for the test file.
Every matching tool event triggers it.',
link: '/en/hooks-guide'
}, {
t: 0.67,
kind: 'claude',
Manuel Navarro Hidalgo.
label: 'npm test output',
tokens: 1200,
color: '#A09E96',
vis: 'brief',
desc: 'Runs the test suite. You see "Running npm
test..." and the pass count, not the full 1,200 tokens
of output.',
link: null
}, {
t: 0.70,
kind: 'claude',
label: 'Summary',
tokens: 400,
color: '#D97757',
vis: 'full',
desc: '"Fixed token rotation. Added regression
test. All tests pass."',
link: null
}, {}, {
t: 0.72,
kind: 'user',
label: 'Your follow-up',
tokens: 40,
color: '#558A42',
vis: 'full',
desc: '"Use a subagent to research session
timeout handling, then fix it"',
 tip: 'Follow-ups add to the same context.
Delegating research to a subagent keeps large file
reads out of your main window.',
link: null
}, {
t: 0.79,
kind: 'claude',
label: 'Spawn research subagent',
tokens: 80,
color: '#D97757',
vis: 'brief',
desc: "Claude delegates the research to a
subagent with a fresh, separate context window. It
loads [Link] and the same MCP and skill
setup, but starts without your conversation history
or the main session's auto memory.",
link: '/en/sub-agents'
}, {
t: 0.795,
kind: 'sub',
label: 'System prompt',
tokens: 0,
subTokens: 900,
color: '#6B6964',
vis: 'hidden',
desc: "The subagent gets its own system prompt,
shorter than the main session's. For the
general-purpose agent, it's a brief prompt plus
environment details. The main session's auto
Manuel Navarro Hidalgo.
memory is not included. If a custom agent has
memory: in its frontmatter, it loads its own separate
[Link] here instead.",
link: '/en/sub-agents#enable-persistent-memory'
}, {
t: 0.80,
kind: 'sub',
label: 'Project [Link] (own copy)',
tokens: 0,
subTokens: 1800,
color: '#6A9BCC',
vis: 'hidden',
desc: "The subagent loads [Link] too.
Same file, same content, but it counts against the
subagent's context, not yours. The built-in Explore
and Plan agents skip this for a smaller context.",
link: '/en/sub-agents'
}, {
t: 0.805,
kind: 'sub',
label: 'MCP tools + skills',
tokens: 0,
subTokens: 970,
color: '#9B7BC4',
vis: 'hidden',
desc: "The subagent has access to the same MCP
servers and skills. It gets most of the parent's tools,
minus several that don't apply in a nested context,
including plan-mode controls, background-task
tools, and by default the Agent tool itself to prevent
recursion.",
link: '/en/sub-agents'
}, {
t: 0.81,
kind: 'sub',
label: 'Task prompt from main',
tokens: 0,
subTokens: 120,
color: '#558A42',
vis: 'hidden',
desc: "Instead of a user prompt, the subagent
receives the task Claude wrote for it: 'Research
session timeout handling in this codebase.'",
link: '/en/sub-agents'
}, {
t: 0.82,
kind: 'sub',
label: 'Read [Link]',
tokens: 0,
subTokens: 2200,
color: '#8A8880',
vis: 'hidden',
desc: "Now the subagent does its work. This file
read fills the subagent's context, not yours.",
link: '/en/sub-agents'
}, {
t: 0.825,
kind: 'sub',
Manuel Navarro Hidalgo.
label: 'Read [Link]',
tokens: 0,
subTokens: 800,
color: '#8A8880',
vis: 'hidden',
desc: "Another file read in the subagent's
separate context.",
link: '/en/sub-agents'
}, {
t: 0.83,
kind: 'sub',
label: 'Read config/*.ts',
tokens: 0,
subTokens: 3100,
color: '#8A8880',
vis: 'hidden',
desc: "The subagent can read as many files as it
needs. None of this touches your main context.",
link: '/en/sub-agents'
}, {
t: 0.85,
kind: 'claude',
label: 'Subagent returns summary',
tokens: 420,
color: '#D97757',
vis: 'brief',
desc: "Only the subagent's final text response
comes back to your context, plus a small metadata
trailer with token counts and duration. The subagent
read 6,100 tokens of files. You got a 420-token
result. That's the context savings.",
link: '/en/sub-agents'
}, {
t: 0.86,
kind: 'claude',
label: "Claude's response",
tokens: 1200,
color: '#D97757',
vis: 'full',
desc: 'Analysis and fix for session timeouts. This
text appears in your terminal.',
link: null
}, {}, {
t: 0.875,
kind: 'user',
label: '!git status',
tokens: 180,
color: '#558A42',
vis: 'full',
desc: "You ran a shell command with the ! prefix
to see which files Claude modified. The command
and its output both enter context as part of your
message. Useful for grounding Claude in command
output without Claude running it.",
link: '/en/interactive-mode#bash-mode-with-prefix'
}, {
t: 0.89,
kind: 'user',
Manuel Navarro Hidalgo.
label: '/commit-push',
tokens: 620,
color: '#558A42',
vis: 'brief',
desc: 'You invoked a skill that has
`disable-model-invocation: true`. Its description was
not in the skill index at startup, so it cost zero
context until this moment. Now the full skill content
loads and Claude follows its instructions to stage,
commit, and push your changes.',
tip: 'Set `disable-model-invocation: true` on skills
with side effects like committing, deploying, or
sending messages. They stay out of context entirely
until you need them.',
link: '/en/skills#control-who-invokes-a-skill'
}, {}, {
t: 0.93,
kind: 'compact',
label: '/compact',
tokens: 0,
color: '#D97757',
vis: 'brief',
desc: 'Replaces the conversation with a
structured summary. You see a "Conversation
compacted" message. The summarization happens
without appearing in your terminal.',
link:
'/en/how-claude-code-works#the-context-window'
}].filter(e => e.t !== undefined), []);
 const VIS_META = {
hidden: {
label: 'Invisible in your terminal',
sub: 'This content does not appear in your
terminal.'
},
brief: {
label: 'One-liner in your terminal',
sub: 'You see a brief mention, not the full
content.'
},
full: {
label: 'Shown in your terminal',
sub: 'The actual content appears in your
terminal.'
}
};
{}
const GATES = [{
at: 0.18,
kind: 'prompt',
text: 'Fix the auth bug where users get 401 after
token refresh',
resumeTo: 0.22
}, {
at: 0.705,
kind: 'prompt',
text: 'Use a subagent to research session timeout
handling, then fix it',
Manuel Navarro Hidalgo.
resumeTo: 0.72
}, {
at: 0.865,
kind: 'bang',
text: '!git status',
resumeTo: 0.875
}, {
at: 0.88,
kind: 'slash',
text: '/commit-push',
resumeTo: 0.89
}, {
at: 0.90,
kind: 'compact',
text: '/compact',
resumeTo: 1
}];
const KIND_META = {
auto: {
badge: 'auto',
detail: 'Auto-loaded',
badgeBg: 'rgba(94,93,89,0.15)',
badgeColor: '#8A8880'
},
user: {
badge: 'you',
detail: 'You typed this',
badgeBg: 'rgba(85,138,66,0.15)',
badgeColor: '#6BA656'
 },
claude: {
badge: 'claude',
detail: "Claude's work",
badgeBg: 'rgba(217,119,87,0.12)',
badgeColor: '#D97757'
},
hook: {
badge: 'hook',
detail: 'Hook (automatic)',
badgeBg: 'rgba(184,134,11,0.15)',
badgeColor: '#CCA020'
},
compact: {
badge: 'compact',
detail: 'Compaction',
badgeBg: 'rgba(217,119,87,0.12)',
badgeColor: '#D97757'
},
sub: {
badge: 'subagent',
detail: "In subagent's context",
badgeBg: 'rgba(155,123,196,0.12)',
badgeColor: '#9B7BC4'
}
};
const LEGEND = [{
c: '#6B6964',
l: 'System'
Manuel Navarro Hidalgo.
}, {
c: '#6A9BCC',
l: '[Link]'
}, {
c: '#E8A45C',
l: 'Memory'
}, {
c: '#D4A843',
l: 'Skills'
}, {
c: '#9B7BC4',
l: 'MCP'
}, {
c: '#4A9B8E',
l: 'Rules'
}, {
c: '#558A42',
l: 'You'
}, {
c: '#8A8880',
l: 'Files'
}, {
c: '#A09E96',
l: 'Output'
}, {
c: '#D97757',
l: 'Claude'
}, {
c: '#B8860B',
 l: 'Hooks'
}];
const fmt = n => n >= 1000 ? (n /
1000).toFixed(1).replace(/\.0$/, '') + 'K' : n + '';
const [time, setTime] = useState(0);
const [playing, setPlaying] = useState(false);
const [hovIdx, setHovIdx] = useState(null);
const [selIdx, setSelIdx] = useState(null);
const [hovCat, setHovCat] = useState(null);
const [gatesPassed, setGatesPassed] =
useState(0);
const [mounted, setMounted] = useState(false);
const [hasInteracted, setHasInteracted] =
useState(false);
const lastRef = useRef(null);
const scrollRef = useRef(null);
const detailRef = useRef(null);
useEffect(() => setMounted(true), []);
const activeGate = [Link]((g, i) => i >=
gatesPassed && time >= [Link] && time <
[Link]);
use Effect(() => {
if (!playing) return;
let raf;
let stopped = false;
const tick = ts => {
if (stopped) return;
if (!last [Link]) [Link] = ts;
const dt = (ts - [Link]) / 1000;
Manuel Navarro Hidalgo.
[Link] = ts;
setTime(prev => {
const next = prev + dt * 0.032;
const gate = [Link]((g, i) => i >=
gatesPassed && next >= [Link] && prev <
[Link]);
if (gate) {
stopped = true;
setPlaying(false);
return [Link];
}
if (next >= 1) {
stopped = true;
setPlaying(false);
return 1;
}
return next;
});
if (!stopped) raf = requestAnimationFrame(tick);
};
raf = requestAnimationFrame(tick);
return () => {
stopped = true;
cancelAnimationFrame(raf);
[Link] = null;
};
}, [playing, gatesPassed]);
const sendPrompt = () => {
if (!activeGate) return;
 const isCompact = [Link] === 'compact';
setGatesPassed(n => n + 1);
setTime([Link]);
setSelIdx(null);
setHovIdx(null);
if (!isCompact) setPlaying(true);
};
const visibleCount = [Link](e => e.t <=
time).length;
const preCompactVisible = useMemo(() =>
[Link](0, visibleCount), [EVENTS,
visibleCount]);
const compactGateIdx = [Link] - 1;
const isCompacted = gatesPassed >
compactGateIdx && [Link](e =>
[Link] === 'compact');
const {visible, preCompactTotal} = useMemo(() => {
const nonCompact = [Link](e
=> [Link] !== 'compact');
if (!isCompacted) {
return {
visible: preCompactVisible,
preCompactTotal: 0
};
}
{}
const autoLoads = [Link](e => [Link]
=== 'auto' && e.t < STARTUP_END &&
![Link]);
Manuel Navarro Hidalgo.
const summarized = [Link](e => e.t >=
STARTUP_END && [Link] !== 'sub');
const sumTokens = [Link]((s, e) => s
+ [Link], 0);
const summaryBlock = {
t: STARTUP_END,
kind: 'compact',
label: 'Conversation summary',
tokens: [Link](sumTokens * 0.12),
color: '#A09E96',
vis: 'hidden',
desc: `All ${[Link]} conversation
events condensed into one structured summary.
The summary keeps: your requests and intent, key
technical concepts, files examined or modified with
important code snippets, errors and how they were
fixed, pending tasks, and current work. It replaces
the verbatim conversation: full tool outputs and
intermediate reasoning are gone. Claude can still
reference the work but won't have the exact code it
read earlier.`,
link:
'/en/how-claude-code-works#the-context-window'
};
return {
visible: [...autoLoads, summaryBlock],
preCompactTotal: [Link]((s, e) => s
+ [Link], 0)
};
 }, [preCompactVisible, isCompacted]);
const {blocks, totalTokens} = useMemo(() => {
const bl = [Link]((e, visIdx) => ({
...e,
id: [Link] + e.t,
visIdx
})).filter(e => [Link] > 0 || [Link] ===
'Conversation summary');
return {
blocks: bl,
totalTokens: [Link]((s, b) => s + [Link], 0)
};
}, [visible]);
const subTotal = useMemo(() => [Link](e =>
[Link] === 'sub').reduce((s, e) => s + ([Link] ||
0), 0), [visible]);
useEffect(() => {
if (![Link]) return;
if (isCompacted) [Link]({
top: 0,
behavior: 'smooth'
}); else if (playing || activeGate)
[Link] =
[Link];
}, [[Link], !!activeGate, isCompacted]);
const rootRef = useRef(null);
const keyStateRef = useRef({});
const [isFullscreen, setIsFullscreen] =
useState(false);
Manuel Navarro Hidalgo.
[Link] = {
time,
activeGate,
sendPrompt,
hasInteracted
};
useEffect(() => {
const onFsChange = () =>
setIsFullscreen(!![Link]);
[Link]('fullscreenchange',
onFsChange);
return () =>
[Link]('fullscreenchange',
onFsChange);
}, []);
const toggleFullscreen = () => {
if (![Link]) return;
if ([Link])
[Link](); else
[Link]().catch(() => {});
};
useEffect(() => {
const onKey = e => {
const tag = [Link];
if (tag === 'INPUT' || tag === 'BUTTON' || tag ===
'TEXTAREA' || tag === 'SELECT' ||
[Link]) return;
if (![Link]) return;
 const rect =
[Link]();
if ([Link] === 0 && [Link] === 0) return;
if ([Link] < 0 || [Link] >
[Link]) return;
if ([Link] === 'Space') {
const {time: t, activeGate: g, sendPrompt: send,
hasInteracted: hi} = [Link];
if (!hi) return;
[Link]();
if (t === 0) setPlaying(true); else if (g) send();
else if (t >= 1) {
setTime(0);
setGatesPassed(0);
setSelIdx(null);
setHovIdx(null);
setPlaying(true);
} else setPlaying(p => !p);
}
};
[Link]('keydown', onKey);
return () =>
[Link]('keydown', onKey);
}, []);
const pct = totalTokens / MAX * 100;
const barColor = pct > 75 ? '#D97757' : pct > 50 ?
'#B8860B' : '#558A42';
const activeIdx = selIdx !== null ? selIdx : hovIdx;
Manuel Navarro Hidalgo.
const hovEvent = activeIdx !== null ?
visible[activeIdx] : null;
useEffect(() => {
if ([Link]) [Link] =
0;
}, [hovEvent]);
const focusT = hovEvent ? hovEvent.t : time;
const takeaway = isCompacted ? 'Compaction
replaces the conversation with a structured
summary. System prompt, [Link], memory,
and MCP tools reload automatically. The skill listing
is the one exception. Only skills you actually
invoked are preserved.' : focusT < STARTUP_END ?
'A lot loads before you type anything. [Link],
memory, skills, and MCP tools are all in context
before your first prompt.' : focusT < 0.28 ? "Your
prompt is tiny compared to what's already loaded.
Most of Claude's context is project knowledge, not
your words." : focusT < 0.50 ? 'Each file Claude
reads grows the context. Path-scoped rules load
automatically alongside matching files.' : focusT <
0.71 ? 'Hooks fire automatically on tool events.
Output reaches Claude via additionalContext JSON.
Exit code 2 surfaces stderr to Claude. Plain stdout
on exit 0 goes to the debug log, not the transcript.' :
focusT < 0.79 ? 'Follow-up questions keep building
on the same context. Everything from earlier is still
there.' : focusT < 0.87 ? "The subagent works in its
own separate context window. None of its file reads
touch yours. Only the final summary comes back." :
focusT < 0.88 ? 'Bang commands run in your shell
and prefix the output to your next message. Useful
for grounding Claude in command results without it
running them.' : focusT < 0.90 ? 'User-only skills
stay out of context entirely until you invoke them.
The skill index at startup only lists skills Claude can
call on its own.' : '/compact summarizes the
conversation to free space while keeping key
information. In a real session, run it when context
starts affecting performance or before a long new
task.';
const terminalView = isCompacted ? 'A
"Conversation compacted" message. The
summarization happens silently.' : focusT <
STARTUP_END ? 'The input box, waiting for your
first message. Everything above loads silently
before you type anything.' : focusT < 0.28 ? 'Your
prompt. Claude hasn\'t started working yet.' : focusT
< 0.52 ? 'Your prompt and "Reading files...". Rules
show as one-line "Loaded" notices, not their
content.' : focusT < 0.72 ? "Claude's response and
file diffs. Hooks fire silently. Tool output like npm
test shows as a brief summary, not the full content."
: focusT < 0.79 ? 'Your follow-up prompt.' : focusT <
0.86 ? "A brief notice that a subagent is working,
then its result. You don't see the subagent's
individual file reads." : focusT < 0.90 ? "Claude's
response, your git status output, and the
Manuel Navarro Hidalgo.
commit-push skill running." : 'Your full
conversation. /compact is available to run.';
const mono = 'var(--font-mono, ui-monospace,
SFMono-Regular, Menlo, monospace)';
const renderWithCode = s => [Link]('`').map((part,
i) => i % 2 === 1 ? <code key={i} style={{
fontFamily: mono,
fontSize: '0.92em',
background: 'var(--cw-track)',
padding: '1px 4px',
borderRadius: 3
}}>{part}</code> : part);
if (!mounted) return null;
return <>
<div className="cw-mobile-fallback">
This interactive timeline works best on a larger
screen. See <a href="#what-the-timeline-shows"
style={{
color: '#D97757'
}}>the written breakdown below</a> for the same
concepts.
</div>
<div className="cw-root" ref={rootRef}
onClickCapture={() => setHasInteracted(true)}
style={isFullscreen ? {
height: '100vh',
borderRadius: 0,
display: 'flex',
flexDirection: 'column'
 } : {}}>
<style>{`
.cw-root {
--cw-bg: #FAFAF8;
--cw-text: #1A1918;
--cw-text-2: #3D3C38;
--cw-text-3: #5E5D59;
--cw-text-dim: #6E6C64;
--cw-text-faint: #8A8880;
--cw-surface: rgba(0,0,0,0.025);
--cw-surface-2: rgba(0,0,0,0.04);
--cw-border: rgba(0,0,0,0.08);
--cw-track: rgba(0,0,0,0.04);
--cw-hover: rgba(0,0,0,0.04);
--cw-rail: rgba(0,0,0,0.08);
--cw-scrollbar: rgba(0,0,0,0.22);
background: var(--cw-bg);
border-radius: 12px;
overflow: hidden;
font-family: var(--font-sans, -apple-system,
BlinkMacSystemFont, sans-serif);
color: var(--cw-text);
border: 1px solid var(--cw-border);
}
.dark .cw-root {
--cw-bg: #111110;
--cw-text: #E8E6DC;
--cw-text-2: #B8B6AE;
--cw-text-3: #9C9A92;
Manuel Navarro Hidalgo.
--cw-text-dim: #8A8880;
--cw-text-faint: #6E6C64;
--cw-surface: rgba(255,255,255,0.02);
--cw-surface-2: rgba(255,255,255,0.015);
--cw-border: rgba(255,255,255,0.06);
--cw-track: rgba(255,255,255,0.03);
--cw-hover: rgba(255,255,255,0.04);
--cw-rail: rgba(255,255,255,0.04);
--cw-scrollbar: rgba(255,255,255,0.18);
}
.cw-scroll::-webkit-scrollbar { width: 6px; }
.cw-scroll::-webkit-scrollbar-track {
background: transparent; }
.cw-scroll::-webkit-scrollbar-thumb {
background: var(--cw-scrollbar); border-radius: 3px;
}
@keyframes cw-blink { 50% { opacity: 0; } }
@keyframes cw-fadein { from { opacity: 0;
transform: translateY(-4px); } to { opacity: 1;
transform: translateY(0); } }
.cw-compacted-row { animation: cw-fadein 0.3s
ease-out backwards; }
.cw-mobile-fallback { display: none; padding:
14px 16px; border-radius: 8px; font-size: 14px;
border: 1px solid rgba(0,0,0,0.1); background:
rgba(0,0,0,0.03); }
.dark .cw-mobile-fallback { border-color:
rgba(255,255,255,0.15); background:
rgba(255,255,255,0.04); }
 @media (max-width: 700px) {
.cw-root { display: none !important; }
.cw-mobile-fallback { display: block; }
}
`}</style>

{}
<div style={{
padding: '16px 20px 12px',
display: 'flex',
alignItems: 'flex-end',
gap: 24
}}>
<div style={{
flex: 1,
minWidth: 0
}}>
<div style={{
fontSize: 18,
fontWeight: 600,
letterSpacing: -0.3,
lineHeight: 1
}}>
Explore the context window
</div>
<div style={{
fontSize: 14,
color: 'var(--cw-text-dim)',
marginTop: 4
Manuel Navarro Hidalgo.
}}>
A simulated session showing what enters
context and what it costs
</div>
</div>
<div style={{
textAlign: 'right',
flexShrink: 0
}}>
<div style={{
fontFamily: mono,
fontSize: 20,
fontWeight: 600,
color: barColor,
letterSpacing: -0.5,
lineHeight: 1
}}>
~{fmt(totalTokens)}<span style={{
fontSize: 15,
fontWeight: 500,
marginLeft: 4
}}>tokens</span>
</div>
<div style={{
fontFamily: mono,
fontSize: 13,
color: 'var(--cw-text-dim)',
marginTop: 2
 }} title="Token counts are illustrative. Actual values
vary with your [Link] size, MCP servers, and
file lengths.">
/ {fmt(MAX)} · illustrative
</div>
</div>
</div>

{}
<div style={{
padding: '0 20px'
}}>
<div style={{
height: 4,
borderRadius: 2,
background: 'var(--cw-track)',
overflow: 'hidden',
marginBottom: 6
}}>
<div style={{
width: pct + '%',
height: '100%',
background: barColor,
transition: 'width 0.6s cubic-bezier(0.4, 0, 0.2, 1),
background 0.3s'
}} />
</div>
<div style={{
height: 28,
Manuel Navarro Hidalgo.
borderRadius: 5,
background: 'var(--cw-track)',
border: '1px solid var(--cw-border)',
overflow: 'hidden',
display: 'flex'
}}>
{[Link]((b, i) => {
const w = [Link]([Link] / MAX * 100, 0.15);
const isHov = [Link] === activeIdx;
const catMatch = hovCat && [Link] === hovCat;
const dimmed = hovCat ? !catMatch : activeIdx
!== null && !isHov;
return <div key={[Link]} onMouseEnter={() =>
setHovIdx([Link])} onMouseLeave={() =>
setHovIdx(null)} onClick={() => setSelIdx(selIdx ===
[Link] ? null : [Link])} style={{
width: w + '%',
height: '100%',
background: [Link],
opacity: isHov || catMatch ? 1 : dimmed ? 0.25 :
0.65,
borderRight: i < [Link] - 1 ? '0.5px solid
var(--cw-border)' : 'none',
transition: 'opacity 0.15s',
cursor: 'pointer'
}} />;
})}
</div>
<div style={{
 display: 'flex',
gap: 12,
marginTop: 6,
flexWrap: 'wrap',
justifyContent: 'space-between'
}}>
<div style={{
display: 'flex',
gap: 12,
flexWrap: 'wrap'
}}>
{[Link](x => {
const active = hovCat === x.c;
return <div key={x.l} onMouseEnter={() =>
setHovCat(x.c)} onMouseLeave={() =>
setHovCat(null)} style={{
display: 'flex',
alignItems: 'center',
gap: 4,
padding: '2px 6px',
borderRadius: 4,
cursor: 'pointer',
background: active ? 'var(--cw-hover)' :
'transparent',
transition: 'background 0.1s'
}}>
<div style={{
width: 6,
height: 6,
Manuel Navarro Hidalgo.
borderRadius: 1.5,
background: x.c,
opacity: active ? 1 : 0.7
}} />
<span style={{
fontSize: 12,
color: active ? 'var(--cw-text)' :
'var(--cw-text-dim)'
}}>{x.l}</span>
</div>;
})}
</div>
<div style={{
display: 'flex',
gap: 6,
alignItems: 'center',
fontSize: 12,
color: 'var(--cw-text-dim)'
}}>
<svg width="11" height="11" viewBox="0 0
24 24" fill="none" stroke="#558A42"
strokeWidth="2.5">
<path d="M1 12s4-8 11-8 11 8 11 8-4 8-11
8-11-8-11-8z" /><circle cx="12" cy="12" r="3" />
</svg>
<span>= appears in your terminal</span>
</div>
</div>
</div>
 {}
<div style={{
display: 'flex',
padding: '14px 20px 0',
gap: 16,
height: isFullscreen ? 'calc(100vh - 240px)' : 420
}}>

{}
<div ref={scrollRef} className="cw-scroll"
style={{
flex: 1,
minWidth: 0,
overflowY: 'auto',
paddingRight: 8,
scrollBehavior: 'smooth'
}}>
{[Link] === 0 && !playing && <div
style={{
height: '100%',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
gap: 16
}}>
<div style={{
fontFamily: mono,
Manuel Navarro Hidalgo.
fontSize: 16,
color: 'var(--cw-text-dim)',
display: 'flex',
alignItems: 'center',
gap: 8
}}>
<span style={{
color: 'var(--cw-text-faint)'
}}>$</span>
<span>claude</span>
<span style={{
display: 'inline-block',
width: 8,
height: 16,
background: 'var(--cw-text-dim)',
opacity: 0.5,
animation: 'cw-blink 1s step-end infinite'
}} />
</div>
<button onClick={() => setPlaying(true)}
style={{
padding: '10px 20px',
borderRadius: 8,
border: '1px solid rgba(217,119,87,0.3)',
background: 'rgba(217,119,87,0.08)',
color: '#D97757',
fontSize: 15,
fontWeight: 600,
cursor: 'pointer',
 display: 'flex',
alignItems: 'center',
gap: 8
}}>
<span>▶</span>
<span>Start session</span>
</button>
<div style={{
fontSize: 13,
color: 'var(--cw-text-faint)',
maxWidth: 280,
textAlign: 'center',
lineHeight: 1.5
}}>
Watch what loads into context, from the
moment you run <code style={{
fontFamily: mono
}}>claude</code> through a full conversation.
</div>
</div>}
{isCompacted && <div style={{
marginBottom: 10,
padding: '10px 12px',
borderRadius: 6,
background: 'rgba(217,119,87,0.05)',
border: '1px solid rgba(217,119,87,0.15)'
}}>
<div style={{
fontSize: 13,
Manuel Navarro Hidalgo.
fontWeight: 600,
color: '#D97757',
marginBottom: 3
}}>
After /compact
</div>
<div style={{
fontSize: 13,
color: 'var(--cw-text-3)',
lineHeight: 1.5,
fontFamily: mono
}}>
{fmt(preCompactTotal)} →
{fmt(totalTokens)} tokens · freed
{fmt(preCompactTotal - totalTokens)}
</div>
<div style={{
fontSize: 13,
color: 'var(--cw-text-dim)',
lineHeight: 1.5,
marginTop: 4
}}>
This is what's left in context: startup
content, which lives outside the message history
and reloads after compaction, plus a structured
summary of the entire conversation. Skill
descriptions don't reload.
</div>
</div>}
 {time > 0 && [Link] > 0 && <div style={{
fontSize: 12,
fontWeight: 700,
color: 'var(--cw-text-faint)',
textTransform: 'uppercase',
letterSpacing: 0.6,
marginBottom: 6,
paddingLeft: 28
}}>
{isCompacted ? 'Reloaded after compact' :
'Before you type anything'}
</div>}

{time > 0 && [Link]((evt, i) => {

const meta = KIND_META[[Link]];
const isHop = hovId === i;
const prevKind = i > 0 ? visible[i - 1].kind : null;
const Sub = [Link] === 'sub';
const enteringSubagent = isSub && prevKind !==
'sub';
const leavingSubagent = prevKind === 'sub' &&
!isSub;
let showPhase = null;
if ([Link] === 'user' && prevKind !== 'user')
showPhase = 'You'; else if ([Link] === 'claude' &&
prevKind === 'user') showPhase = 'Claude works';
else if ([Link] === 'Conversation summary')
showPhase = 'Summarized by /compact';
Manuel Navarro Hidalgo.
const isNewRow = isCompacted && !([Link] ===
'auto' && evt.t < STARTUP_END);
return <div key={[Link] + evt.t}
className={isNewRow ? 'cw-compacted-row' : ''}
style={isNewRow ? {
animationDelay: `${i * 60}ms`
} : {}}>
{showPhase && <div style={{
fontSize: 12,
fontWeight: 700,
color: 'var(--cw-text-faint)',
textTransform: 'uppercase',
letterSpacing: 0.6,
marginTop: 14,
margin Bottom: 6,
paddingLeft: 28
}}>
{showPhase}
</div>}
{enteringSubagent && <div style={{
marginLeft: 28,
margin Top: 6,
marginBottom: 2,
paddingLeft: 10,
borderLeft: '2px solid rgba(155,123,196,0.4)',
fontSize: 12,
fontWeight: 600,
color: '#9B7BC4',
textTransform: 'uppercase',
 letterSpacing: 0.5
}}>
Subagent's separate context window
</div>}
{leavingSubagent && <div style={{
marginLeft: 28,
marginBottom: 6,
paddingLeft: 10,
paddingBottom: 6,
borderLeft: '2px solid rgba(155,123,196,0.4)',
fontSize: 12,
color: 'var(--cw-text-dim)',
fontFamily: mono
}}>
↓ {fmt(subTotal)} tokens stayed in
subagent's context · only the summary returns
</div>}
<div onMouseEnter={() => setHovIdx(i)}
onMouseLeave={() => setHovIdx(null)} onClick={()
=> setSelIdx(selIdx === i ? null : i)} style={{
display: 'flex',
alignItems: 'flex-start',
borderRadius: 6,
cursor: 'pointer',
background: selIdx === i || isHov ?
'var(--cw-hover)' : 'transparent',
outline: selIdx === i ? '1px solid
rgba(217,119,87,0.4)' : 'none',
Manuel Navarro Hidalgo.
opacity: hovCat && [Link] !== hovCat ? 0.35 :
1,
transition: 'background 0.1s, opacity 0.15s',
marginLeft: isSub ? 28 : 0,
paddingLeft: isSub ? 10 : 0,
borderLeft: isSub ? '2px solid
rgba(155,123,196,0.4)' : 'none'
}}>
<div style={{
width: 28,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
paddingTop: 8,
flexShrink: 0
}}>
<div style={{
width: [Link] === 'user' || [Link] ===
'compact' ? 10 : 7,
height: [Link] === 'user' || [Link] ===
'compact' ? 10 : 7,
borderRadius: '50%',
background: [Link],
opacity: isHov ? 1 : 0.6,
transition: 'opacity 0.15s',
boxShadow: isHov ? `0 0 8px ${[Link]}40` :
'none'
}} />
{i < [Link] - 1 && <div style={{
 width: 1.5,
flex: 1,
background: 'var(--cw-rail)',
marginTop: 2,
minHeight: 6
}} />}
</div>
<div style={{
flex: 1,
minWidth: 0,
padding: '5px 10px 5px 4px',
display: 'flex',
alignItems: 'center',
gap: 8
}}>
<span style={{
fontSize: 12,
fontWeight: 600,
padding: '1px 5px',
borderRadius: 3,
background: [Link],
color: [Link],
flexShrink: 0,
fontFamily: mono
}}>
{[Link]}
</span>
<span style={{
fontSize: 15,
Manuel Navarro Hidalgo.
fontFamily: mono,
color: isHov ? 'var(--cw-text)' : [Link] === 'user'
? '#558A42' : [Link] === 'auto' ? 'var(--cw-text-dim)'
: 'var(--cw-text-2)',
flex: 1,
minWidth: 0,
overflow: 'hidden',
textOverflow: 'ellipsis',
whiteSpace: 'nowrap',
fontWeight: [Link] === 'user' ? 550 : 400
}}>
{[Link]}
</span>
{[Link] > 0 && <span style={{
fontSize: 12,
fontFamily: mono,
color: 'var(--cw-text-faint)',
flexShrink: 0
}}>
+{fmt([Link])}
</span>}
{[Link] > 0 && <span style={{
fontSize: 12,
fontFamily: mono,
color: '#9B7BC4',
flexShrink: 0,
opacity: 0.6
}}>
+{fmt([Link])}
 </span>}
{[Link] > 0 && <div style={{
width: 50,
height: 5,
borderRadius: 2,
background: 'var(--cw-track)',
flexShrink: 0,
overflow: 'hidden'
}}>
<div style={{
width: [Link]([Link] / 5000 * 100, 100) +
'%',
height: '100%',
background: [Link],
opacity: isHov ? 0.8 : 0.4,
transition: 'opacity 0.15s'
}} />
</div>}
<span style={{
width: 14,
flexShrink: 0,
display: 'flex',
justifyContent: 'center'
}} title={VIS_META[[Link]].label}>
{[Link] !== 'hidden' && <svg
width="12" height="12" viewBox="0 0 24 24"
fill="none" stroke={[Link] === 'full' ? '#558A42' :
'currentColor'} style={{
color: 'var(--cw-text-faint)',
Manuel Navarro Hidalgo.
opacity: [Link] === 'full' ? 1 : 0.5
}} strokeWidth="2">
<path d="M1 12s4-8 11-8 11 8 11 8-4
8-11 8-11-8-11-8z" /><circle cx="12" cy="12" r="3" />
</svg>}
</span>
</div>
</div>
</div>;
})}

{activeGate && ([Link] === 'prompt' ||

[Link] === 'bang' || [Link] ===
'slash') && <div style={{
paddingLeft: 28,
marginTop: 12,
paddingRight: 8
}}>
<div style={{
fontSize: 11,
fontWeight: 600,
color: '#6BA656',
fontFamily: mono,
textTransform: 'uppercase',
letterSpacing: 0.5,
marginBottom: 4,
paddingLeft: 2
}}>
You type in your terminal
 </div>
<div style={{
display: 'flex',
alignItems: 'flex-start',
gap: 8,
padding: '10px 12px',
borderRadius: 6,
background: 'rgba(85,138,66,0.06)',
border: '1px solid rgba(85,138,66,0.2)'
}}>
<span style={{
color: '#558A42',
fontSize: 15,
fontFamily: mono,
flexShrink: 0
}}>❯</span>
<span style={{
fontSize: 15,
fontFamily: mono,
color: 'var(--cw-text-2)',
flex: 1,
lineHeight: 1.5
}}>
{[Link]}
<span style={{
display: 'inline-block',
width: 7,
height: 13,
marginLeft: 2,
Manuel Navarro Hidalgo.
background: '#558A42',
opacity: 0.5,
verticalAlign: 'middle',
animation: 'cw-blink 1s step-end infinite'
}} />
</span>
<button onClick={sendPrompt} style={{
padding: '5px 12px',
borderRadius: 5,
border: 'none',
background: '#558A42',
color: '#fff',
fontSize: 13,
fontWeight: 600,
cursor: 'pointer',
flexShrink: 0
}}>
{[Link] === 'prompt' ? 'Send ↵' :
'Run ↵'}
</button>
</div>
</div>}
{activeGate && [Link] === 'compact'
&& <div style={{
paddingLeft: 28,
marginTop: 12,
paddingRight: 8
}}>
<div style={{
 padding: '12px 14px',
borderRadius: 6,
background: 'rgba(217,119,87,0.06)',
border: '1px solid rgba(217,119,87,0.25)'
}}>
<div style={{
fontSize: 13,
color: 'var(--cw-text-3)',
marginBottom: 8,
lineHeight: 1.5
}}>
Context is at <span style={{
fontFamily: mono,
fontWeight: 600,
color: barColor
}}>{fmt(totalTokens)} tokens</span>.
Run <code style={{
fontFamily: mono,
background: 'var(--cw-track)',
padding: '1px 4px',
borderRadius: 3
}}>/compact</code> to
summarize older exchanges and free
space for more work.
</div>
<div style={{
display: 'flex',
alignItems: 'center',
gap: 8
Manuel Navarro Hidalgo.
}}>
<span style={{
color: '#D97757',
fontSize: 15,
fontFamily: mono
}}>❯</span>
<span style={{
fontSize: 15,
fontFamily: mono,
color: 'var(--cw-text-2)',
flex: 1
}}>
{[Link]}
</span>
<button onClick={sendPrompt} style={{
padding: '5px 12px',
borderRadius: 5,
border: 'none',
background: '#D97757',
color: '#fff',
fontSize: 13,
fontWeight: 600,
cursor: 'pointer',
flexShrink: 0
}}>
Run ↵
</button>
</div>
</div>
 </div>}
</div>

{}
<div style={{
width: 300,
flexShrink: 0,
display: 'flex',
flexDirection: 'column'
}}>
<div ref={detailRef} className="cw-scroll"
style={{
padding: '14px 16px',
borderRadius: 10,
background: 'var(--cw-surface)',
border: '1px solid var(--cw-border)',
flex: 1,
minHeight: 0,
overflowY: 'auto',
display: 'flex',
flexDirection: 'column',
gap: 10
}}>
{hovEvent ? <div>
<div style={{
display: 'flex',
alignItems: 'center',
gap: 8,
marginBottom: 8
Manuel Navarro Hidalgo.
}}>
<div style={{
width: 10,
height: 10,
borderRadius: 3,
background: [Link],
opacity: 0.8
}} />
<span style={{
fontSize: 16,
fontWeight: 600
}}>{[Link]}</span>
</div>
<div style={{
display: 'flex',
width: 'fit-content',
padding: '3px 8px',
borderRadius: 4,
marginBottom: 8,
background:
KIND_META[[Link]].badgeBg
}}>
<span style={{
fontSize: 12,
fontWeight: 600,
color: KIND_META[[Link]].badgeColor
}}>
{KIND_META[[Link]].detail}
</span>
 </div>
{[Link] > 0 && <div style={{
fontSize: 14,
fontFamily: mono,
color: 'var(--cw-text-dim)',
marginBottom: 6
}}>
{fmt([Link])} tokens
</div>}
{[Link] > 0 && <div style={{
fontSize: 14,
fontFamily: mono,
color: '#9B7BC4',
marginBottom: 6
}}>
{fmt([Link])} tokens in the
subagent's context
</div>}
<p style={{
fontSize: 15,
color: 'var(--cw-text-3)',
lineHeight: 1.55,
margin: 0
}}>
{renderWithCode([Link])}
</p>
<div style={{
marginTop: 10,
padding: '8px 10px',
Manuel Navarro Hidalgo.
borderRadius: 6,
background: [Link] === 'full' ?
'rgba(85,138,66,0.08)' : 'var(--cw-surface-2)',
border: '1px solid ' + ([Link] === 'full' ?
'rgba(85,138,66,0.2)' : 'var(--cw-border)')
}}>
<div style={{
display: 'flex',
alignItems: 'center',
gap: 6,
marginBottom: 3
}}>
<span style={{
fontSize: 13,
color: [Link] === 'full' ? '#558A42' :
'var(--cw-text-dim)'
}}>
{[Link] === 'full' ? '●' :
[Link] === 'brief' ? '◐' : '○'}
</span>
<span style={{
fontSize: 12,
fontWeight: 600,
color: 'var(--cw-text-2)'
}}>
{VIS_META[[Link]].label}
</span>
</div>
<div style={{
 fontSize: 13,
color: 'var(--cw-text-dim)',
lineHeight: 1.4
}}>
{VIS_META[[Link]].sub}
</div>
</div>
{[Link] && <div style={{
marginTop: 10,
padding: '8px 10px',
borderRadius: 6,
background: 'rgba(85,138,66,0.06)',
border: '1px solid rgba(85,138,66,0.15)'
}}>
<div style={{
fontSize: 12,
fontWeight: 600,
color: '#558A42',
marginBottom: 3,
display: 'flex',
alignItems: 'center',
gap: 4

💡
}}>
<span> </span> Save context
</div>
<div style={{
fontSize: 13,
color: 'var(--cw-text-3)',
lineHeight: 1.5
Manuel Navarro Hidalgo.
}}>
{renderWithCode([Link])}
</div>
</div>}
{[Link] && <a href={[Link]}
style={{
display: 'inline-block',
marginTop: 10,
fontSize: 13,
color: '#D97757',
textDecoration: 'none',
borderBottom: '1px solid rgba(217,119,87,0.3)'
}}>
Learn more →
</a>}
</div> : <div style={{
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
textAlign: 'center',
gap: 4,
padding: '12px 0 4px'
}}>
<div style={{
fontSize: 22,

👁
opacity: 0.2
}}> </div>
<div style={{
fontSize: 14,
 fontWeight: 500,
color: 'var(--cw-text-dim)'
}}>Hover or click any event</div>
<div style={{
fontSize: 12,
color: 'var(--cw-text-faint)',
lineHeight: 1.4,
maxWidth: 200
}}>
Hover to preview. Click to pin so you can
scroll.
</div>
</div>}

<div style={{
padding: '10px 12px',
borderRadius: 8,
background: 'rgba(217,119,87,0.05)',
border: '1px solid rgba(217,119,87,0.12)'
}}>
<div style={{
fontSize: 11,
fontWeight: 700,
color: '#D97757',
textTransform: 'uppercase',
letterSpacing: 0.5,
marginBottom: 3
}}>
Key takeaway
Manuel Navarro Hidalgo.
</div>
<div style={{
fontSize: 13,
color: 'var(--cw-text-3)',
lineHeight: 1.5
}}>
{takeaway}
</div>
</div>

<div style={{
padding: '10px 12px',
borderRadius: 8,
background: 'var(--cw-surface-2)',
border: '1px solid var(--cw-border)'
}}>
<div style={{
fontSize: 11,
fontWeight: 700,
color: 'var(--cw-text-dim)',
textTransform: 'uppercase',
letterSpacing: 0.5,
marginBottom: 3
}}>
In your terminal you see
</div>
<div style={{
fontSize: 13,
color: 'var(--cw-text-3)',
 lineHeight: 1.5
}}>
{terminalView}
</div>
</div>
</div>
</div>
</div>

{}
<div style={{
padding: '10px 20px 14px',
display: 'flex',
alignItems: 'center',
gap: 10
}}>
<button aria-label={time >= 1 ? 'Restart' :
activeGate ? 'Continue' : playing ? 'Pause' : 'Play'}
onClick={() => {
if (time >= 1) {
setTime(0);
setGatesPassed(0);
setSelIdx(null);
setHovIdx(null);
setPlaying(true);
} else if (activeGate) sendPrompt(); else
setPlaying(!playing);
}} style={{
width: 30,
Manuel Navarro Hidalgo.
height: 30,
borderRadius: 6,
border: 'none',
background: 'rgba(217,119,87,0.1)',
color: '#D97757',
cursor: 'pointer',
fontSize: 15,
fontWeight: 700,
display: 'flex',
alignItems: 'center',
justifyContent: 'center'

⏸
}}>
{time >= 1 ? '↺' : playing ? ' ' : '▶'}
</button>
<div style={{
flex: 1,
height: 3,
borderRadius: 2,
background: 'var(--cw-track)',
overflow: 'hidden'
}}>
<div style={{
width: time * 100 + '%',
height: '100%',
background: '#D97757',
transition: 'width 0.1s linear'
}} />
</div>
<span style={{
 fontSize: 12,
fontFamily: mono,
color: 'var(--cw-text-faint)',
minWidth: 30
}}>
{[Link](time * 100)}%
</span>
<button onClick={toggleFullscreen}
aria-label={isFullscreen ? 'Exit fullscreen' : 'Enter
fullscreen'} title={isFullscreen ? 'Exit fullscreen' :
'Fullscreen'} style={{
width: 28,
height: 28,
borderRadius: 6,
border: '1px solid var(--cw-border)',
background: 'var(--cw-surface)',
color: 'var(--cw-text-dim)',
cursor: 'pointer',
fontSize: 15,
flexShrink: 0,
marginLeft: 4,
display: 'flex',
alignItems: 'center',
justifyContent: 'center'
}}>
{isFullscreen ? '⤡' : '⛶'}
</button>
</div>
</div>
Manuel Navarro Hidalgo.
</>;
};

La ventana de contexto de Claude Code contiene

todo lo que Claude sabe sobre su sesión: sus
instrucciones, los archivos que lee, sus propias
respuestas y contenido que nunca aparece en su
terminal. La línea de tiempo a continuación muestra
una sesión completa desde el inicio hasta la
compactación: qué se carga antes de que escriba,
qué agrega cada lectura de archivo, regla y hook
mientras Claude trabaja, y cómo un subagent
mantiene las lecturas grandes fuera de su contexto.
Vea [el desglose escrito](#what-the-timeline-shows)
para el mismo contenido como una lista.

<ContextWindow />

<h2 id="what-the-timeline-shows">
Qué muestra la línea de tiempo
</h2>

La sesión recorre un flujo realista con conteos de

tokens representativos:

* **Antes de que escriba algo**: [Link],

memoria automática, nombres de herramientas MCP
y descripciones de skills se cargan en el contexto.
Su propia configuración puede agregar más aquí,
como un [estilo de salida](/es/output-styles) o texto
de [`--append-system-prompt`](/es/cli-reference),
que ambos van al prompt del sistema de la misma
manera.
* **Mientras Claude trabaja**: cada lectura de
archivo se suma al contexto, [reglas con alcance de
ruta](/es/memory#path-specific-rules) se cargan
automáticamente junto con archivos coincidentes, y
un [hook PostToolUse](/es/hooks-guide) se activa
después de cada edición.
* **El prompt de seguimiento**: un
[subagent](/es/sub-agents) maneja la investigación
en su propia ventana de contexto separada, por lo
que las lecturas de archivos grandes se mantienen
fuera de la suya. Solo el resumen y un pequeño
remolque de metadatos regresan.
* **Al final**: `/compact` reemplaza la conversación
con un resumen estructurado. La mayoría del
contenido de inicio se recarga automáticamente; la
tabla a continuación muestra qué sucede con cada
mecanismo.

<h2 id="what-survives-compaction">
Qué sobrevive a la compactación
</h2>

Cuando una sesión larga se compacta, Claude Code

resume el historial de conversación para que quepa
Manuel Navarro Hidalgo.
en la ventana de contexto. Lo que sucede con sus
instrucciones depende de cómo se cargaron:

| Mecanismo | Después de
la compactación
|
| :-------------------------------------------------- |
:--------------------------------------------------------------------------
-------------------------------------- |
| Prompt del sistema y estilo de salida | Sin
cambios; no es parte del historial de mensajes
|
| [Link] de raíz del proyecto y reglas sin
alcance | Re-inyectadas desde el disco
|
| Memoria automática |
Re-inyectada desde el disco
|
| Reglas con frontmatter `paths:` |
Perdidas hasta que se lea un archivo coincidente
nuevamente |
| [Link] anidado en subdirectorios |
Perdido hasta que se lea un archivo en ese
subdirectorio nuevamente
|
| Cuerpos de skills invocados |
Re-inyectados, limitados a 5,000 tokens por skill y
25,000 tokens en total; los más antiguos se
descartan primero |
| Hooks | No aplicable;
los hooks se ejecutan como código, no como
contexto |

Las reglas con alcance de ruta y los archivos

[Link] anidados se cargan en el historial de
mensajes cuando se lee su archivo de activación,
por lo que la compactación los resume junto con
todo lo demás. Se recargan la próxima vez que
Claude lee un archivo coincidente. Si una regla debe
persistir a través de la compactación, elimine el
frontmatter `paths:` o muévalo a [Link] de raíz
del proyecto.

Los cuerpos de skills se re-inyectan después de la

compactación, pero los skills grandes se truncan
para ajustarse al límite por skill, y los skills
invocados más antiguos se descartan una vez que
se excede el presupuesto total. El truncamiento
mantiene el inicio del archivo, por lo que coloque
las instrucciones más importantes cerca de la parte
superior de `[Link]`.

<h2 id="when-your-context-fills-up">
Cuando su contexto se llena
</h2>

Claude Code se compacta automáticamente a

medida que se acerca al límite, por lo que una
Manuel Navarro Hidalgo.
ventana de contexto llena no termina su sesión. El
paso automático funciona de la misma manera que
el paso `/compact` en la línea de tiempo. Vea
[Cuando el contexto se
llena](/es/how-claude-code-works#when-context-fills
-up) para saber qué preserva.

También puede actuar antes de que se ejecute el

paso automático:

* **Compactar con un enfoque**: ejecute `/compact`

con instrucciones, como `/compact focus on the
auth bug fix`, antes de comenzar una tarea nueva
larga. El resumen mantiene lo que usted elige en
lugar de lo que el paso automático adivina que es
importante.
* **Limpiar entre tareas**: ejecute `/clear` cuando
cambie a trabajo no relacionado. La conversación
antigua desplaza los archivos que necesita a
continuación y cuesta tokens en cada mensaje.
* **Delegar lecturas grandes**: envíe investigación a
un [subagent](/es/sub-agents) para que el contenido
del archivo permanezca en su ventana de contexto,
no en la suya.

Si necesita una ventana más grande en lugar de una

conversación más pequeña, Fable 5, Sonnet 5, Opus
4.6 y posteriores, y Sonnet 4.6 admiten una ventana
de contexto de 1 millón de tokens. Vea [Contexto
extendido](/es/model-config#extended-context) para
disponibilidad por plan y cómo seleccionar una
variante de modelo `[1m]`. Sonnet 5 se ejecuta a 1M
sin variante `[1m]` para seleccionar; vea [Ventana de
contexto de Sonnet
5](/es/model-config#sonnet-5-context-window) para
sus umbrales de compactación automática y la
excepción de la puerta de enlace LLM. La
compactación funciona de la misma manera en el
límite más grande.

<h2 id="check-your-own-session">
Verifique su propia sesión
</h2>

La visualización utiliza números representativos.

Para ver su uso real de contexto en cualquier
momento, ejecute `/context` para un desglose en
vivo por categoría con sugerencias de optimización.
Ejecute `/memory` para verificar qué archivos
[Link] y memoria automática se cargaron al
inicio.

<h2 id="related-resources">
Recursos relacionados
</h2>
Manuel Navarro Hidalgo.
Para una cobertura más profunda de las
características mostradas en la línea de tiempo, vea
estas páginas:

* [Extender Claude Code](/es/features-overview):

cuándo usar [Link] vs skills vs reglas vs
hooks vs MCP
* [Almacenar instrucciones y
memorias](/es/memory): jerarquía de [Link] y
memoria automática
* [Subagents](/es/sub-agents): delegar investigación
a una ventana de contexto separada
* [Mejores prácticas](/es/best-practices): gestionar
el contexto como su restricción principal
* [Almacenamiento en caché de
prompts](/es/prompt-caching): qué acciones
invalidan el prefijo en caché
* [Reducir el uso de
tokens](/es/costs#reduce-token-usage): estrategias
para mantener el uso de contexto bajo
Cómo Claude Code utiliza el
almacenamiento en caché de prompts

> Claude Code gestiona automáticamente el

almacenamiento en caché de prompts. Vea por qué
un cambio de modelo desencadena un turno lento
sin caché, qué cuesta `/compact`, por qué las
ediciones de [Link] no se aplican a mitad de
sesión, y cómo verificar su tasa de aciertos de
caché.

El almacenamiento en caché de prompts hace que

Claude Code sea más rápido y eficiente en costos.
Sin almacenamiento en caché, la API reprocesaría
su historial completo en cada turno. Con
Manuel Navarro Hidalgo.
almacenamiento en caché, reutiliza lo que ya
procesó y solo realiza trabajo nuevo para lo que
cambió.

Claude Code gestiona el almacenamiento en caché

de prompts automáticamente, a menos que lo
[desactive](#disable-prompt-caching). Aún es útil
saber cómo funciona el almacenamiento en caché
de prompts, porque algunas acciones invalidan el
caché y hacen que la siguiente respuesta sea más
lenta y costosa mientras se reconstruye. Esta
página cubre qué acciones son esas, por qué
algunos ajustes esperan un reinicio para aplicarse,
y cómo verificar el rendimiento del caché cuando el
uso parece alto.

<h2 id="how-the-cache-is-organized">
Cómo se organiza el caché
</h2>

Cada vez que envía un mensaje en Claude Code,

realiza una nueva solicitud de API. El modelo no
recuerda nada entre solicitudes, por lo que Claude
Code reenvía el contexto completo: el prompt del
sistema, el contexto de su proyecto, cada mensaje
anterior y resultado de herramienta, y su nuevo
mensaje. El contenido nuevo se añade al final, lo
que significa que la mayoría de cada solicitud es
idéntica a la anterior. El almacenamiento en caché
de prompts es cómo la API evita reprocesar la parte
que no cambió.

La API almacena en caché haciendo coincidir el

inicio de cada solicitud, llamado el prefijo, con el
contenido que procesó recientemente. En un turno
normal, el prefijo es la solicitud anterior completa y
solo el intercambio más reciente es nuevo. La
coincidencia es exacta, por lo que un cambio en
cualquier lugar del prefijo recalcula todo después de
él. No hay almacenamiento en caché por archivo o
por segmento. Vea [cómo funciona el
almacenamiento en caché de
prompts]([Link]
with-claude/prompt-caching#how-prompt-caching-w
orks) en la referencia de API para el mecanismo
subyacente.

<img
src="[Link]
9Wvm/images/[Link]?fit=max&a
uto=format&n=VbDJw--l6T9a9Wvm&q=85&s=f2e8f0b
8298a50305fe428ca3f1d1594"
className="dark:hidden" alt="Cuatro turnos
mostrados como barras horizontales crecientes. La
solicitud de cada turno contiene todo del turno
anterior más el intercambio más reciente añadido al
final. En los turnos dos y tres, el prefijo sin cambios
se lee del caché y solo se procesa el nuevo
Manuel Navarro Hidalgo.
intercambio. En el turno cuatro, el prompt del
sistema cambió, por lo que el prefijo ya no coincide
y toda la solicitud se reprocesa y se escribe."
width="720" height="454"
data-path="images/[Link]" />

<img
src="[Link]
9Wvm/images/[Link]?fit=m
ax&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=74
34a04e08187edd26ec6c3dd332f624"
className="hidden dark:block" alt="Cuatro turnos
mostrados como barras horizontales crecientes. La
solicitud de cada turno contiene todo del turno
anterior más el intercambio más reciente añadido al
final. En los turnos dos y tres, el prefijo sin cambios
se lee del caché y solo se procesa el nuevo
intercambio. En el turno cuatro, el prompt del
sistema cambió, por lo que el prefijo ya no coincide
y toda la solicitud se reprocesa y se escribe."
width="720" height="454"
data-path="images/[Link]"
/>

Para aprovechar al máximo la coincidencia de

prefijos, Claude Code ordena cada solicitud para
que el contenido que rara vez cambia entre turnos
venga primero:
| Capa | Contenido
| Cambia cuando
|
| --------------------- |
------------------------------------------------------------------------- |
---------------------------------------------------------------------------
------------ |
| Prompt del sistema | Instrucciones principales,
definiciones de herramientas, estilo de salida | El
conjunto de definiciones de herramientas cargadas
cambia, o Claude Code se actualiza |
| Contexto del proyecto | [Link], memoria
automática, reglas sin alcance | La
sesión comienza, o después de `/clear` o `/compact`
|
| Conversación | Sus mensajes, respuestas de
Claude, resultados de herramientas | Cada
turno |

Un cambio en la capa de conversación deja el

prompt del sistema y el contexto del proyecto en
caché. Un cambio en el prompt del sistema invalida
todo, porque todo el contenido posterior ahora se
encuentra detrás de un prefijo diferente. La tercera
columna proporciona desencadenantes comunes en
lugar de una lista exhaustiva, y las secciones a
continuación cubren el conjunto completo, incluido
contenido como el estilo de salida que se fija al
inicio de la sesión.
Manuel Navarro Hidalgo.

La regla de coincidencia de prefijos explica la

mayoría de los comportamientos en esta página.
[Plan
mode](/es/permission-modes#analyze-before-you-ed
it-with-plan-mode) y [skill loading](/es/skills), por
ejemplo, añaden sus instrucciones como mensajes
de conversación, por lo que el prefijo en caché
permanece intacto.

Dos ajustes no son parte del texto del prompt en

absoluto, por lo que no aparecen en la tabla de
capas, pero ambos son parte de la clave de caché:

* **Model**: cada modelo tiene su propio caché.

Cambiar de modelo recalcula toda la solicitud
incluso cuando el contenido es idéntico. Vea
[Cambiar de modelo](#switching-models) a
continuación.
* **Effort level**: cada nivel de esfuerzo tiene su
propio caché para el mismo modelo. Cambiarlo a
mitad de sesión recalcula toda la solicitud, y Claude
Code le pide que confirme antes de aplicar el
cambio. Vea [Cambiar nivel de
esfuerzo](#changing-effort-level) a continuación.

<Tip>
Elija su modelo y nivel de esfuerzo al principio de
una sesión, luego guarde `/compact` para
descansos naturales entre tareas. Cuantos menos
cambios realice a mitad de tarea, mayor será su tasa
de aciertos de caché.
</Tip>

<h3 id="where-the-cache-lives">
Dónde vive el caché
</h3>

El almacenamiento en caché ocurre del lado del

servidor, en cualquier infraestructura que sirva su
modelo. Dónde es eso depende de cómo se
autentique:

* **Clave de API, suscripción de Claude, o [Claude

Platform on AWS](/es/claude-platform-on-aws)**: el
caché vive en la infraestructura de Anthropic,
accedido a través de la [Claude
API]([Link]
* **Bedrock o Vertex AI**: el caché vive en la
infraestructura de servicio de su proveedor de nube
* **Foundry**: las solicitudes se enrutan a la
infraestructura de Anthropic
* **`ANTHROPIC_BASE_URL` personalizado o [LLM
gateway](/es/llm-gateway)**: el caché vive donde se
reenvíen sus solicitudes, y si el almacenamiento en
caché funciona depende de la puerta de enlace
Manuel Navarro Hidalgo.
Para lo que cada proveedor almacena y procesa,
vea [data usage](/es/data-usage). Dondequiera que
viva el caché, las entradas expiran después de un
período de inactividad, y [Cache
lifetime](#cache-lifetime) a continuación cubre el
TTL y cómo extenderlo.

<h2 id="actions-that-invalidate-the-cache">
Acciones que invalidan el caché
</h2>

Estas acciones hacen que la siguiente solicitud

pierda parte o todo el caché. Verá un turno más
lento y costoso de una sola vez, después del cual el
nuevo prefijo se almacena en caché. La mayoría de
ellas se pueden evitar a mitad de tarea una vez que
sabe que tienen un costo. Un cambio de modelo
puede parecer gratuito hasta que note el turno más
lento que sigue.

* [Cambiar de modelo](#switching-models)
* [Cambiar el nivel de
esfuerzo](#changing-effort-level)
* [Activar el modo rápido](#turning-on-fast-mode)
* [Conectar o desconectar un servidor
MCP](#connecting-or-disconnecting-an-mcp-server)
* [Habilitar o deshabilitar un
plugin](#enabling-or-disabling-a-plugin)
* [Denegar una herramienta
completa](#denying-an-entire-tool)
* [Compactar la
conversación](#compacting-the-conversation)
* [Actualizar Claude Code](#upgrading-claude-code)

<h3 id="switching-models">
Cambiar de modelo
</h3>

Cada modelo tiene su propio caché. Cambiar con

[`/model`](/es/model-config#setting-your-model)
significa que la siguiente solicitud lee todo el
historial de conversación sin aciertos de caché,
aunque el contenido sea idéntico.

La [configuración de modelo
`opusplan`](/es/model-config#opusplan-model-settin
g) se resuelve a Opus durante el modo de plan y
Sonnet durante la ejecución, por lo que cada
alternancia de modo de plan es un cambio de
modelo e inicia un caché nuevo.

El [respaldo automático de
modelo](/es/model-config#automatic-model-fallback
) en Fable 5 también es un cambio de modelo.
Cuando un clasificador de seguridad marca una
solicitud, Claude Code la vuelve a ejecutar en el
Manuel Navarro Hidalgo.
modelo Opus predeterminado y la sesión continúa
allí.

<h3 id="changing-effort-level">
Cambiar el nivel de esfuerzo
</h3>

El caché se indexa por [nivel de

esfuerzo](/es/model-config#adjust-effort-level) así
como por modelo, por lo que cambiar con `/effort`
significa que la siguiente solicitud lee todo el
historial de conversación sin aciertos de caché. Una
vez que una conversación ha comenzado, Claude
Code muestra un diálogo de confirmación antes de
aplicar un cambio de esfuerzo que invalidaría el
caché. Un cambio que se resuelve al mismo nivel ya
en vigor, como establecer explícitamente el valor
predeterminado del modelo, omite el diálogo y
mantiene el caché.

<h3 id="turning-on-fast-mode">
Activar el modo rápido
</h3>

Habilitar [modo rápido](/es/fast-mode) añade un

encabezado de solicitud que forma parte de la clave
de caché, por lo que la siguiente solicitud lee todo el
historial de conversación sin aciertos de caché.
Esos tokens de entrada sin caché se facturan a
[tasas de modo
rápido](/es/fast-mode#understand-the-cost-tradeoff),
por lo que activarlo al inicio de una sesión cuesta
menos que activarlo profundamente en una larga.
Habilitar el modo rápido desde un modelo que no es
Opus también [cambia su
modelo](#switching-models), lo que inicia un caché
nuevo por sí solo.

El costo se aplica una vez por conversación.

Después del primer turno de modo rápido, Claude
Code sigue enviando el encabezado y varía solo la
configuración de velocidad de la solicitud, que no
forma parte de la clave de caché. Desactivar el
modo rápido, la [reversión automática a velocidad
estándar](/es/fast-mode#handle-rate-limits) después
de un límite de velocidad, y activarlo nuevamente
más tarde mantienen el caché. `/clear` y `/compact`
restablecen esto, ya que reconstruyen el caché en
esos puntos de todas formas.

<Note>
Mantener el encabezado en las alternaciones
requiere Claude Code v2.1.86 o posterior. En
versiones anteriores, cada alternancia de modo
rápido y reversión de límite de velocidad invalida el
caché.
</Note>
Manuel Navarro Hidalgo.
<h3
id="connecting-or-disconnecting-an-mcp-server">
Conectar o desconectar un servidor MCP
</h3>

Las definiciones de herramientas se encuentran en

la capa del prompt del sistema, por lo que el caché
se invalida cuando el conjunto de definiciones de
herramientas en la solicitud cambia entre turnos.
Alternar la [herramienta de asesor](/es/advisor) es
una excepción: su definición se encuentra después
del punto de ruptura de caché, por lo que habilitar o
deshabilitar `/advisor` mantiene el prefijo en caché
intacto. Si un cambio de [servidor MCP](/es/mcp)
hace esto depende de si sus herramientas se
difieren por [búsqueda de
herramientas](/es/mcp#scale-with-mcp-tool-search)
o se cargan en el prefijo:

* **Herramientas diferidas**, el valor predeterminado

en modelos compatibles: un servidor que se
conecta, desconecta o cambia su lista de
herramientas solo añade contenido nuevo y no
perturba nada ya almacenado en caché.
* **Herramientas cargadas en el prefijo**: cualquier
cambio en ellas invalida el caché. Esto sucede
cuando [la búsqueda de herramientas no está
disponible o está
deshabilitada](/es/mcp#configure-tool-search),
como en modelos Haiku, en Vertex AI, o con una
puerta de enlace `ANTHROPIC_BASE_URL`
personalizada. También sucede para un servidor o
herramienta marcada
[`alwaysLoad`](/es/mcp#exempt-a-server-from-deferr
al), y para definiciones mantenidas al frente por
[carga basada en
umbral](/es/mcp#configure-tool-search).

Cuando las herramientas se cargan en el prefijo, la

causa más común de una invalidación es un
servidor que se conecta o desconecta a mitad de
sesión, lo que puede suceder sin ninguna acción de
su parte: el proceso de un servidor stdio sale, una
sesión HTTP expira, o un servidor [se reconecta
automáticamente después de una falla
transitoria](/es/mcp#automatic-reconnection). Un
servidor conectado también puede enviar una
[actualización de herramienta
dinámica](/es/mcp#dynamic-tool-updates) que
cambia su lista de herramientas.

Editar su configuración de MCP no cambia el caché

por sí solo. La nueva configuración entra en vigor
solo después de un reinicio, que es cuando el
servidor se conecta o desconecta.

<h3 id="enabling-or-disabling-a-plugin">
Habilitar o deshabilitar un plugin
Manuel Navarro Hidalgo.
</h3>

Los [plugins](/es/plugins) agrupan varios tipos de

componentes, y el costo de un cambio depende de
qué componentes proporciona el plugin. Skills,
commands, agents, hooks, servidores LSP,
monitores y temas nunca invalidan el caché:
cualquier cosa que agreguen a la solicitud se añade
después de la conversación existente, por lo que la
siguiente solicitud paga por el contenido nuevo
pero aún lee todo lo anterior desde el caché.

La excepción es un plugin que proporciona

[servidores
MCP](/es/plugins-reference#mcp-servers). Habilitar
o deshabilitar uno sigue las mismas reglas que
[conectar o desconectar un servidor
MCP](#connecting-or-disconnecting-an-mcp-server)
: el caché sobrevive cuando las herramientas del
servidor se difieren, y la siguiente solicitud vuelve a
leer toda la conversación cuando se cargan en el
prefijo.

Los cambios de plugin se aplican cuando ejecuta

[`/reload-plugins`](/es/discover-plugins#apply-plugin
-changes-without-restarting) o inicia una nueva
sesión. El costo, ya sean anuncios añadidos o una
relectura completa, se muestra en el primer turno
después de la recarga, no cuando ejecuta `/plugin
install`, `/plugin enable`, o `/plugin disable`. {/*
min-version: 2.1.163 */}A partir de v2.1.163, cuando
una recarga activaría la relectura completa,
`/reload-plugins` muestra una advertencia y no
aplica la recarga. Pase `--force` para aplicar de todas
formas.

Deshabilitar un plugin que habilitó anteriormente en

la sesión restaura la forma de solicitud anterior. Si
ese prefijo aún está dentro de su [vida útil de
caché](#cache-lifetime), la siguiente solicitud lee la
entrada de caché más antigua en lugar de
reconstruir.

<h3 id="denying-an-entire-tool">
Denegar una herramienta completa
</h3>

Agregar un nombre de herramienta simple como

`Bash` o `WebFetch` como una [regla de
denegación](/es/permissions#manage-permissions)
elimina esa herramienta del contexto de Claude por
completo. Las definiciones de herramientas
integradas se cargan en la capa del prompt del
sistema, por lo que agregar o eliminar una de estas
reglas a mitad de sesión invalida el caché. El
cambio entra en vigor en el siguiente turno, ya sea
que lo agregue a través de `/permissions` o
Manuel Navarro Hidalgo.
[editando un archivo de configuración
directamente](/es/settings#when-edits-take-effect).

Solo una regla de denegación que coincida en la

posición del nombre de la herramienta tiene este
efecto: un nombre de herramienta simple, la forma
equivalente `Bash(*)`, o un [glob de nombre de
herramienta](/es/permissions#tool-name-wildcards)
como `"*"`. Un glob que coincida solo con
herramientas MCP, como `"mcp__*"`, elimina esas
herramientas de la misma manera pero deja el caché
intacto cuando las herramientas coincidentes se
[difieren](#connecting-or-disconnecting-an-mcp-ser
ver), el valor predeterminado, ya que las
definiciones diferidas nunca estuvieron en el prefijo
en caché. Las reglas de denegación con alcance
como `Bash(rm *)`, y todas las reglas de permitir y
preguntar, no cambian qué herramientas ve Claude.
Claude Code las verifica cuando Claude intenta una
llamada, dejando el prefijo intacto.

<h3 id="compacting-the-conversation">
Compactar la conversación
</h3>

[Compaction](/es/context-window#what-survives-co
mpaction) reemplaza su historial de mensajes con
un resumen. Por diseño, esto invalida la capa de
conversación, ya que la siguiente solicitud tiene un
historial nuevo y más corto que no comparte un
prefijo con el anterior. Claude Code reutiliza la capa
del prompt del sistema y recarga el contexto del
proyecto desde el disco, que solo tiene aciertos de
caché si [Link] y la memoria no han cambiado
desde que comenzó la sesión.

Para producir el resumen, Claude Code envía una

solicitud única con el mismo prompt del sistema,
herramientas e historial que su conversación, más
una instrucción de resumen añadida como un
mensaje de usuario final. Porque comparte su
prefijo, esa solicitud lee el caché existente en lugar
de reprocesar el historial completo. La mayoría del
tiempo de compactación se dedica a generar el
resumen, no a una pérdida de caché. El turno que
sigue reconstruye el caché de conversación solo
para el resumen mucho más corto, por lo que el
turno posterior a la compactación no es la parte
lenta.

<Tip>
La compactación funciona a su favor cuando el
contexto que descarta es contenido que ya no
necesita. Para elegir cuándo ocurre su sobrecarga,
ejecute `/compact` en un descanso natural en su
trabajo, como entre tareas, en lugar de esperar a
que la compactación automática se active a mitad
de tarea. Si ha seguido un camino que desea
Manuel Navarro Hidalgo.
abandonar completamente,
[`/rewind`](#rewinding-the-conversation) a un turno
anterior en su lugar. Rewind trunca de vuelta a un
prefijo que ya está en caché, en lugar de construir
uno nuevo como lo hace la compactación.
</Tip>

<h3 id="upgrading-claude-code">
Actualizar Claude Code
</h3>

Una nueva versión de Claude Code típicamente

actualiza el prompt del sistema o las definiciones de
herramientas, por lo que la primera solicitud
después de una actualización reconstruye el caché
desde el principio.
[Auto-update](/es/setup#auto-updates) descarga
nuevas versiones en segundo plano pero las aplica
en el siguiente lanzamiento, nunca a mitad de
sesión, por lo que ve esto como un primer turno sin
caché después de reiniciar en lugar de una sorpresa
durante una sesión. Establezca
`DISABLE_AUTOUPDATER=1` para controlar
cuándo se aplican las actualizaciones.

<Note>
[Reanudar una
sesión](/es/sessions#resume-a-session) después de
una actualización reprocesa todo el historial de
conversación sin aciertos de caché, ya que el
historial ahora se encuentra detrás de un prompt del
sistema diferente. El costo se escala con la duración
de la conversación reanudada, por lo que el primer
turno de vuelta a una sesión larga puede ser la
solicitud más costosa que envíe.
</Note>

<h2 id="actions-that-keep-the-cache">
Acciones que mantienen el caché
</h2>

Estas acciones ya sea se añaden al final de la

conversación o no tocan la solicitud en absoluto.
Algunas de ellas, como editar [Link] o
cambiar el estilo de salida, también son por qué un
cambio de ajuste espera un reinicio para aplicarse.

* [Editar archivos en su
repositorio](#editing-files-in-your-repository)
* [Editar [Link] a mitad de
sesión](#editing-claude-md-mid-session)
* [Cambiar el estilo de
salida](#changing-output-style)
* [Cambiar el modo de
permiso](#changing-permission-mode)
* [Invocar skills y
comandos](#invoking-skills-and-commands)
* [Ejecutar `/recap`](#running-%2Frecap)
Manuel Navarro Hidalgo.
* [Rewind de la
conversación](#rewinding-the-conversation)
* [Generar un
subagente](#subagents-and-the-cache)

<h3 id="editing-files-in-your-repository">
Editar archivos en su repositorio
</h3>

El contenido del archivo entra en contexto solo

cuando Claude lo lee, y las lecturas se añaden a la
conversación. Editar un archivo que Claude leyó
anteriormente no cambia retroactivamente la lectura
anterior en el historial. En su lugar, Claude Code
añade un `<system-reminder>` notando que el
archivo cambió, y Claude lo relee si es necesario.

<h3 id="editing-claude-md-mid-session">
Editar [Link] a mitad de sesión
</h3>

Sus archivos [Link] de raíz de proyecto y

nivel de usuario se leen una vez al inicio de la
sesión y se mantienen en memoria. Editarlos a
mitad de sesión no invalida el caché, pero la edición
tampoco se aplica. Claude continúa trabajando con
la versión que se cargó al inicio de la sesión. El
nuevo contenido se carga en el siguiente `/clear`,
`/compact`, o reinicio.
[Archivos [Link] anidados en
subdirectorios](/es/memory) y [reglas con
frontmatter
`paths:`](/es/memory#path-specific-rules) se cargan
más tarde, cuando Claude lee por primera vez un
archivo coincidente. Editar uno antes de que se
cargue sí tiene efecto. Después de que se carga, el
contenido es parte del historial de conversación,
por lo que una edición a mitad de sesión no lo
cambia retroactivamente.

<h3 id="changing-output-style">
Cambiar el estilo de salida
</h3>

[Output style](/es/output-styles) es parte del prompt

del sistema, que Claude Code lee una vez al inicio
de la sesión. Cambiarlo a través de `/config` o la
configuración `outputStyle` a mitad de sesión no
invalida el caché, pero el cambio tampoco se aplica.
Claude continúa usando el estilo que se cargó al
inicio de la sesión. El nuevo estilo se carga en el
siguiente `/clear` o reinicio.

<h3 id="changing-permission-mode">
Cambiar el modo de permiso
</h3>
Manuel Navarro Hidalgo.
Cambiar entre [permission
modes](/es/permission-modes), como de
predeterminado a aceptar ediciones, no cambia el
prompt del sistema o las definiciones de
herramientas, por lo que los cambios de modo son
seguros para el caché. La excepción es el modo de
plan con la configuración de modelo
[`opusplan`](/es/model-config#opusplan-model-setti
ng), que cambia el modelo entre Opus y Sonnet
cuando entra o sale del modo de plan. Eso hace que
el cambio de modo sea un [cambio de
modelo](#switching-models).

<h3 id="invoking-skills-and-commands">
Invocar skills y comandos
</h3>

[Skills](/es/skills) y [commands](/es/commands)
inyectan sus instrucciones como mensajes de
usuario en el punto de invocación. Nada anterior en
la conversación cambia.

<h3 id="running-/recap">
Ejecutar `/recap`
</h3>

[`/recap`](/es/interactive-mode#session-recap)
genera un resumen para mostrar en su terminal. A
diferencia de `/compact`, añade el resumen como
salida de comando en lugar de reemplazar su
historial de mensajes, por lo que el prefijo en caché
permanece intacto.

<h3 id="rewinding-the-conversation">
Rewind de la conversación
</h3>

[`/rewind`](/es/checkpointing) trunca su
conversación de vuelta a un turno anterior. El
historial restante es el mismo contenido del que se
construyó el caché en ese punto, y las capas del
prompt del sistema y contexto del proyecto no
cambian, por lo que la siguiente solicitud acierta la
entrada de caché anterior. Cada turno desde
entonces ha leído a través de ese prefijo, que
mantuvo la entrada activa incluso si el turno original
fue hace más tiempo que el TTL.

Restaurar puntos de control de archivo junto con la

conversación no tiene efecto separado en el caché.
El contenido del archivo entra en contexto solo
cuando Claude lo lee, igual que [editar archivos en
su repositorio](#editing-files-in-your-repository).

<h2 id="cache-lifetime">
Duración del caché
</h2>
Manuel Navarro Hidalgo.
Los prefijos en caché expiran después de un
período de inactividad. Cada solicitud que acierta el
caché reinicia el temporizador, por lo que el caché
permanece activo mientras continúe trabajando.
Después de una brecha lo suficientemente larga, la
siguiente solicitud recalcula la entrada completa y
restablece el caché, que es por qué el primer turno
después de alejarse puede ser notablemente más
lento.

El tiempo de vida (TTL) controla cuánto tiempo la

brecha el caché sobrevive. La API ofrece dos: un
TTL de cinco minutos, y un [TTL de una
hora]([Link]
-claude/prompt-caching#1-hour-cache-duration) que
mantiene el caché activo a través de descansos más
largos pero [factura escrituras de caché a una tasa
más
alta]([Link]
claude/prompt-caching#pricing). Claude Code elige
el TTL para usted según cómo se autentique, y
puede anularlo con variables de entorno.

<h3 id="on-a-claude-subscription">
En una suscripción de Claude
</h3>

En una suscripción de Claude, Claude Code solicita

automáticamente el TTL de una hora. El uso se
incluye en su plan en lugar de facturarse por token,
por lo que el TTL más largo no le cuesta nada extra
y solo afecta cuánto tiempo su caché permanece
activo.

Si ha superado el límite de uso de su plan y Claude

Code está utilizando [créditos de
uso]([Link]
9-extra-usage-for-paid-claude-plans), se le factura
por ese uso, por lo que Claude Code
automáticamente reduce el TTL a cinco minutos.

<h3 id="on-an-api-key-or-third-party-provider">
En una clave de API o proveedor de terceros
</h3>

En una clave de API, Bedrock, Vertex, Foundry, o

Claude Platform on AWS, paga las tasas por token,
por lo que el TTL permanece en los cinco minutos
más baratos por defecto. Para optar por el [TTL de
una
hora]([Link]
-claude/prompt-caching#1-hour-cache-duration),
establezca `ENABLE_PROMPT_CACHING_1H=1`.

En Bedrock, el soporte de almacenamiento en caché

de prompts, la longitud mínima de prefijo
almacenable en caché, y la disponibilidad de TTL de
una hora varían según el modelo. Si los recuentos
Manuel Navarro Hidalgo.
de tokens de caché permanecen en cero, verifique
[modelos soportados, regiones y
límites]([Link]
/userguide/[Link]#prompt-caching-m
odels) en la documentación de Bedrock.

<h3 id="override-the-ttl">
Anular el TTL
</h3>

Establezca `FORCE_PROMPT_CACHING_5M=1`
para forzar el TTL de cinco minutos
independientemente de la autenticación. Esto es útil
cuando está depurando el comportamiento del
caché, comparando los dos TTL, o anulando un
`ENABLE_PROMPT_CACHING_1H` establecido en
[managed settings](/es/settings#settings-files).

<h2 id="cache-scope">
Alcance del caché
</h2>

En Claude Code, el caché está efectivamente

limitado a una máquina y directorio. El prompt del
sistema incorpora el directorio de trabajo,
plataforma, shell, versión del SO, y rutas de
memoria automática, por lo que dos sesiones en
directorios diferentes construyen prefijos diferentes
y se pierden el caché del otro. Eso incluye
worktrees del mismo repositorio, ya que cada
worktree tiene su propio directorio de trabajo.

Las sesiones que ejecuta en paralelo en el mismo

directorio construyen prefijos coincidentes y leen el
caché del otro. Las sesiones secuenciales
comparten el prefijo solo cuando la instantánea de
estado de git al inicio coincide, ya que el prompt del
sistema también captura rama y commits recientes.

El caché de API subyacente es más amplio. Los

cachés están aislados entre organizaciones, y en
algunos proveedores, [entre espacios de trabajo
dentro de una
organización]([Link]
uild-with-claude/prompt-caching#cache-storage-and
-sharing). Dentro de esos límites, cualquier dos
solicitudes con el mismo modelo y prefijo leen el
mismo caché. Para llamadores de Agent SDK que
ejecutan flotas de procesos automatizados, vea
[mejorar el almacenamiento en caché de prompts
entre usuarios y
máquinas](/es/agent-sdk/modifying-system-prompts
#improve-prompt-caching-across-users-and-machin
es) para suprimir las secciones por máquina del
prompt del sistema y compartir el caché entre
máquinas.

<h2 id="check-cache-performance">
Manuel Navarro Hidalgo.
Verificar el rendimiento del caché
</h2>

El rendimiento del caché se muestra como dos

recuentos de tokens que la API reporta en cada
respuesta. La forma más directa de verlos en vivo
es un [script de statusline](/es/statusline) que lee el
objeto `current_usage`:

| Campo | Significado
|
| ----------------------------- |
---------------------------------------------------------------------------
---------------------------------- |
| `cache_creation_input_tokens` | Tokens escritos
en el caché en este turno, facturados a la tasa de
escritura de caché |
| `cache_read_input_tokens` | Tokens servidos
desde caché en este turno, facturados a
aproximadamente el 10% de la tasa de entrada
estándar |

Una alta relación de lectura a creación significa que

el almacenamiento en caché está funcionando bien.
Si la creación permanece alta turno tras turno, algo
está cambiando en su prefijo. La sección [acciones
que invalidan el
caché](#actions-that-invalidate-the-cache) enumera
las causas usuales.
Para visibilidad en toda una organización, el
exportador de OpenTelemetry reporta tokens de
lectura y creación de caché por usuario y sesión.
Vea [Monitor usage](/es/monitoring-usage) para la
referencia de métrica y atributo de evento.

<h2 id="subagents-and-the-cache">
Subagentes y el caché
</h2>

Un [subagent](/es/sub-agents) inicia su propia

conversación con su propio prompt del sistema y
conjunto de herramientas, separado del padre.
Construye su propio caché, comenzando sin
aciertos de caché en su primera llamada y
calentándose a través de sus propios turnos. Los
subagentes usan el TTL de cinco minutos incluso
en una suscripción, ya que el TTL automático de
una hora se aplica a la conversación principal.

El caché del padre no se ve afectado. Desde el lado

del padre, la llamada y resultado del subagente se
añaden a la conversación, dejando el prefijo del
padre intacto.

Un
[fork](/es/sub-agents#fork-the-current-conversation)
, por el contrario, hereda el prompt del sistema del
Manuel Navarro Hidalgo.
padre, herramientas e historial de conversación
exactamente, por lo que su primera solicitud lee el
caché del padre. La llamada de resumen de
compactación descrita en [Compactar la
conversación](#compacting-the-conversation) usa
el mismo enfoque de compartir prefijo.

<h2 id="disable-prompt-caching">
Desactivar el almacenamiento en caché de
prompts
</h2>

Desactivar el almacenamiento en caché es

ocasionalmente útil cuando se depura el
comportamiento del almacenamiento en caché con
un modelo o proveedor específico. Para
desactivarlo, establezca una de estas variables de
entorno a `1`:

| Variable | Efecto |
| ------------------------------- | --------------------------------- |
| `DISABLE_PROMPT_CACHING` | Desactivar
para todos los modelos |
| `DISABLE_PROMPT_CACHING_HAIKU` |
Desactivar solo para Haiku |
| `DISABLE_PROMPT_CACHING_SONNET` |
Desactivar solo para Sonnet |
| `DISABLE_PROMPT_CACHING_OPUS` |
Desactivar solo para Opus |
| `DISABLE_PROMPT_CACHING_FABLE` |
Desactivar solo para Fable |

Para establecer la política de almacenamiento en

caché en toda una organización, coloque cualquiera
de estas o las [variables de TTL](#cache-lifetime) en
el bloque `env` de [configuración
administrada](/es/settings#settings-files). Para uso
normal, deje el almacenamiento en caché habilitado.

<h2 id="related-resources">
Recursos relacionados
</h2>

* [Lecciones de construir Claude Code: El

almacenamiento en caché de prompts lo es
todo]([Link]
-claude-code-prompt-caching-is-everything): la
justificación del diseño para el modo de plan, carga
de herramientas diferida, y compactación
* [Explorar la ventana de
contexto](/es/context-window): qué se carga en
contexto y cuándo
* [Reducir el uso de
tokens](/es/costs#reduce-token-usage): estrategias
más allá del almacenamiento en caché para
gestionar el tamaño del contexto
Manuel Navarro Hidalgo.
* [Rastrear y reducir
costos](/es/agent-sdk/cost-tracking): seguimiento
de tokens de caché y configuración de TTL para
llamadores de Agent SDK
* [Almacenamiento en caché de
prompts]([Link]
with-claude/prompt-caching): el mecanismo de API
subyacente, puntos de interrupción, y precios.