4 4
5# Mejores prácticas para Claude Code5# Mejores prácticas para Claude Code
6 6
7> Consejos y patrones para aprovechar al máximo Claude Code, desde configurar su entorno hasta escalar entre sesiones paralelas.7> Aprovecha más Claude Code: dile a Claude lo que no puede ver, dale una verificación que ejecutar y aplica las reglas que no pueden tener excepciones.
8 8
9Claude Code es un entorno de codificación agencial. A diferencia de un chatbot que responde preguntas y espera, Claude Code puede leer sus archivos, ejecutar comandos, hacer cambios y trabajar autónomamente a través de problemas mientras usted observa, redirige o se aleja completamente.9Claude Code está diseñado de forma que, en la mayoría de los casos, tu primer prompt sencillo en una sesión nueva ya hace lo correcto, sin ninguna configuración de tu parte.
10 10
11Esto cambia cómo trabaja. En lugar de escribir código usted mismo y pedirle a Claude que lo revise, describe lo que desea y Claude descubre cómo construirlo. Claude explora, planifica e implementa.11Por ejemplo:
12 12
13Pero esta autonomía aún viene con una curva de aprendizaje. Claude trabaja dentro de ciertas restricciones que necesita entender.13* Para que los comandos se ejecuten de forma segura sin que tengas que aprobar cada uno, las nuevas sesiones de terminal y VS Code comienzan en [modo automático](https://code.claude.com/docs/es/permission-modes.md#eliminate-prompts-with-auto-mode), donde un clasificador revisa cualquier cosa arriesgada antes de que se ejecute.
14* Para mantener tu conversación principal enfocada mientras el trabajo independiente ocurre en paralelo, Claude delega en subagentes y solo te consulta cuando es necesario.
15* Para que una sesión larga siga adelante sin que tengas que gestionarla, tu conversación se compacta automáticamente antes de que se llene la ventana de contexto.
14 16
15Esta guía cubre patrones que han demostrado ser efectivos en los equipos internos de Anthropic y para ingenieros que usan Claude Code en varios códigos base, lenguajes y entornos. Para saber cómo funciona el bucle agencial, consulte [Cómo funciona Claude Code](https://code.claude.com/docs/es/how-claude-code-works.md).17Esta página explica qué hacer cuando los valores predeterminados no son suficientes. Eso suele ocurrir cuando tu proyecto tiene conocimientos, reglas o restricciones que Claude no puede ver solo a partir del código:
16 18
17***19* Un proceso de despliegue que vive en la cabeza de alguien
20* Un archivo que nunca debe leerse
21* Una verificación que tiene que pasar antes de que algo se considere terminado
22* Un presupuesto que no debes superar
18 23
19La mayoría de las mejores prácticas se basan en una restricción: la ventana de contexto de Claude se llena rápidamente y el rendimiento se degrada a medida que se llena.24Ningún valor predeterminado puede saber esas cosas sobre tu proyecto, así que aquí es donde una pequeña configuración de tu parte vale la pena.
20 25
21La ventana de contexto de Claude contiene toda su conversación, incluido cada mensaje, cada archivo que Claude lee y cada salida de comando. Sin embargo, esto puede llenarse rápidamente. Una única sesión de depuración o exploración de código base podría generar y consumir decenas de miles de tokens.26Cuando una sesión no sale como esperabas, casi siempre es por una de estas razones:
22 27
23Esto importa porque el rendimiento del LLM se degrada a medida que se llena el contexto. Cuando la ventana de contexto se está llenando, Claude puede comenzar a "olvidar" instrucciones anteriores o cometer más errores. La ventana de contexto es el recurso más importante a gestionar. Para ver cómo se llena una sesión en la práctica, [vea un recorrido interactivo](https://code.claude.com/docs/es/context-window.md) de lo que se carga al inicio y cuánto cuesta cada lectura de archivo. Rastree el uso de contexto continuamente con una [línea de estado personalizada](https://code.claude.com/docs/es/statusline.md), y consulte [Reducir el uso de tokens](https://code.claude.com/docs/es/costs.md#reduce-token-usage) para estrategias sobre cómo reducir el uso de tokens.28* Claude construyó algo diferente de lo que tenías en mente, o tiene que redescubrir el mismo dato al inicio de cada sesión. Le falta información que no puede obtener leyendo el repositorio. Consulta [Dile a Claude lo que no puede ver](#tell-claude-what-it-cant-see).
29* Claude dijo que había terminado y no era del todo así, normalmente porque no tenía forma de verificar su propio trabajo. Consulta [Dale a Claude una verificación que ejecutar](#give-claude-a-check-to-run).
30* Claude hizo algo que nunca debe ocurrir en este repositorio, u omitió un paso que siempre debe ocurrir. Un prompt por sí solo no puede garantizar ninguna de las dos cosas. Consulta [Aplica las reglas que no pueden tener excepciones](#enforce-the-rules-that-cant-have-exceptions).
31* Claude lo hizo bien, pero le llevó más tiempo, tokens o solicitudes de permiso de lo que valía la tarea. Consulta [Cambia un valor predeterminado](#change-a-default).
24 32
25***33[Deja que Claude trabaje sin ti](#let-claude-run-without-you) aplica estos mismos cuatro puntos a las ejecuciones desatendidas, y [Lo que puedes dejar de hacer](#what-you-can-stop-doing) enumera los consejos que los modelos actuales han vuelto innecesarios.
26 34
27## Dé a Claude una forma de verificar su trabajo35> [!NOTE]
28
29> [!TIP]
30>36>
31> Dé a Claude una verificación que pueda ejecutar: pruebas, una compilación, una captura de pantalla para comparar. Es la diferencia entre una sesión que observa y una de la que se aleja.37> La configuración para todo un equipo está en una página aparte: [Configura Claude Code para tu organización](https://code.claude.com/docs/es/admin-setup.md).
32 38
33Claude se detiene cuando el trabajo parece estar hecho. Sin una verificación que pueda ejecutar, "parece estar hecho" es la única señal disponible, y usted se convierte en el bucle de verificación: cada error espera a que lo note. Dé a Claude algo que produzca un resultado de aprobado o reprobado, y el bucle se cierra por sí solo. Claude realiza el trabajo, ejecuta la verificación, lee el resultado e itera hasta que la verificación pase.39## Instrucciones deterministas y no deterministas
34 40
35La verificación es cualquier cosa que devuelva una señal que Claude pueda leer en la conversación: un conjunto de pruebas, un código de salida de compilación, un linter, un script que compara la salida con una fixture, o una [captura de pantalla del navegador](https://code.claude.com/docs/es/chrome.md) comparada con un diseño. Ejecute [`/verify`](https://code.claude.com/docs/es/skills#run-and-verify-your-app) usted mismo después de que la verificación de Claude pase para confirmar el cambio contra la aplicación en ejecución.41Cada instrucción que le das a Claude Code es de uno de estos tipos:
36 42
37| Estrategia | Antes | Después |431. No determinista: tú escribes la instrucción y Claude (el modelo) la lee. Puede ser tu prompt, `CLAUDE.md` o un skill. Luego el modelo decide qué hacer con esa información. Normalmente sigue tus indicaciones, y los modelos actuales son buenos entendiendo tu intención sin mucho contexto, pero no hay *garantía* de que siga tus instrucciones. Aún puede decidir no hacer cosas, o hacer otras.
38| - | - | - |442. Determinista: tú configuras la instrucción y Claude Code (el harness) *tiene* que ejecutarla. Puede ser un hook, una regla de denegación o una configuración administrada. Claude Code la aplica siempre, sin importar lo que haya decidido el modelo.
39| **Proporcionar criterios de verificación** | *"implementar una función que valide direcciones de correo electrónico"* | *"escribir una función validateEmail. casos de prueba de ejemplo: [user@example.com](mailto:user@example.com) es verdadero, inválido es falso, [user@.com](mailto:user@.com) es falso. ejecutar las pruebas después de implementar"* |
40| **Verificar cambios de UI visualmente** | *"hacer que el panel de control se vea mejor"* | *"\[pegar captura de pantalla] implementar este diseño. tomar una captura de pantalla del resultado y compararla con la original. listar diferencias y corregirlas"* |
41| **Abordar causas raíz, no síntomas** | *"la compilación está fallando"* | *"la compilación falla con este error: \[pegar error]. corregirlo y verificar que la compilación tenga éxito. abordar la causa raíz, no suprimir el error"* |
42 45
43Una vez que la verificación existe, decida qué tan estrictamente detiene el trabajo:46La mayoría de las cosas en Claude Code existen en ambas formas:
44 47
45* **En un solo mensaje**: pida a Claude que ejecute la verificación e itere en el mismo mensaje, como en la tabla anterior.48| | No determinista (Claude decide) | Determinista (Claude Code lo aplica) |
46* **En toda una sesión**: establezca la verificación como una [condición `/goal`](https://code.claude.com/docs/es/goal). Un evaluador separado la vuelve a verificar después de cada turno y Claude continúa trabajando hasta que se cumpla el objetivo. Si Claude se estanca, Claude Code eventualmente detiene la ejecución con el objetivo aún establecido — vea [cómo funciona la evaluación de /goal](https://code.claude.com/docs/es/goal.md#how-evaluation-works).49| :- | :- | :- |
47* **Como una puerta determinista**: un [hook Stop](https://code.claude.com/docs/es/hooks.md#stop) ejecuta su verificación como un script y bloquea el final del turno hasta que pase. [Stop input](https://code.claude.com/docs/es/hooks.md#stop-input) cubre el límite en bloqueos consecutivos.50| Qué hacer | Tu prompt, `CLAUDE.md`, los skills que Claude elige por sí mismo | Hooks, y los skills que solo tú puedes iniciar |
48* **Por una segunda opinión**: un [subagente de verificación](https://code.claude.com/docs/es/sub-agents.md) o un [flujo de trabajo dinámico](https://code.claude.com/docs/es/workflows.md) que verifica sus propios hallazgos tiene un modelo fresco que intenta refutar el resultado, por lo que el agente que realiza el trabajo no es el que lo califica.51| Qué puede tocar | El clasificador del modo automático | Reglas de denegación, el sandbox en [modo estricto](https://code.claude.com/docs/es/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode), configuración administrada |
52| Cuándo está terminado | Una petición de evidencia, `/goal`, `/code-review` | Pruebas, verificación de tipos, un hook `Stop`, CI |
53| Cuánto gasta | Nivel de esfuerzo, el propio ritmo de Claude | `--max-turns` o [`--max-budget-usd`](https://code.claude.com/docs/es/cli-reference) con `-p`, un [límite de gasto](https://code.claude.com/docs/es/costs.md) que hayas establecido |
54| Quién tiene la última palabra | El resumen de Claude de lo que hizo | Protección de ramas, una persona que aprueba la fusión |
49 55
50Cada paso intercambia configuración por atención. La versión de mensaje funciona en cualquier tarea hoy. Las versiones `/goal` y Stop hook son las que permiten que una ejecución desatendida se complete correctamente sin usted.56La mayor parte del tiempo, quieres que Claude decida. Casi todas las pautas tienen excepciones, y los modelos actuales son buenos leyendo el código que tienen delante y juzgando si una pauta encaja con la situación. Con el código real delante, Claude suele estar mejor posicionado para tomar esa decisión que una regla que escribiste de antemano.
51 57
52Haga que Claude muestre evidencia en lugar de afirmar el éxito: la salida de la prueba, el comando que ejecutó y lo que devolvió, o una captura de pantalla del resultado. Revisar evidencia es más rápido que volver a ejecutar la verificación usted mismo, y funciona para sesiones que no estaba observando.58El tipo determinista es para cuando quieres asegurarte de que ciertas cosas *siempre* ocurran (o nunca ocurran), sin importar lo que decida el modelo. No tiene que ser nada dramático. El modo automático ya [bloquea las cosas dramáticas](https://code.claude.com/docs/es/permission-modes.md#what-the-classifier-blocks-by-default), como un despliegue a producción o un force push sobre el trabajo de otra persona. Normalmente es algo específico de *tu* proyecto, y puede ser tan particular como quieras:
53 59
54***60* Nunca editar el cliente generado en `src/gen/`
61* Siempre ejecutar el script de encabezado de licencia después de crear un archivo
55 62
56## Explore primero, luego planifique, luego codifique63Podrías haber escrito cualquiera de estas como una línea en `CLAUDE.md` o en tu prompt, y Claude la seguiría casi siempre. Pero no importa con cuánta fuerza lo redactes: que Claude siga esa línea en un turno dado sigue siendo decisión de Claude.
57 64
58> [!TIP]65> [!TIP]
59>66>
60> Separe la investigación y la planificación de la implementación para evitar resolver el problema incorrecto.67> Si sigues agregando énfasis a una línea de `CLAUDE.md` y Claude aún la pasa por alto, es señal de que esa línea debería ser un hook. Lo contrario también se cumple: si tienes hooks para cosas que solo son preferencias, elimínalos y deja que Claude decida.
61 68
62Dejar que Claude salte directamente a la codificación puede producir código que resuelve el problema incorrecto. Use [plan mode](https://code.claude.com/docs/es/permission-modes.md#analyze-before-you-edit-with-plan-mode) para separar la exploración de la ejecución.69## Dile a Claude lo que no puede ver
63 70
64El flujo de trabajo recomendado tiene cuatro fases:71> [!TIP]
72>
73> Escribe solo lo que Claude no puede encontrar leyendo el repositorio, o lo que de otro modo pasaría tiempo redescubriendo en cada sesión.
65 74
66**1. Explorar**75Claude comienza cada tarea leyendo tu código, y los modelos actuales son *muy* buenos en esto. Encontrarán la estructura de tus archivos, tus convenciones, tu framework de pruebas y cómo están construidos los componentes existentes, normalmente más rápido de lo que podrías explicarlos. Eso significa que Claude ya sabe la mayor parte de lo que podrías sentir la tentación de escribirle.
67 76
68Ingrese plan mode presionando `Shift+Tab` hasta que la barra de estado muestre `⏸ plan mode on`, o inicie la sesión con `claude --permission-mode plan`. Claude lee archivos y responde preguntas sin hacer cambios.77Lo que no puede encontrar es la información que nunca estuvo en el repositorio:
69 78
70```txt title="claude (plan mode)" wrap theme={null}79* Una decisión que tu equipo tomó en una reunión
71read /src/auth and understand how we handle sessions and login.80* Un proceso de despliegue que vive en la cabeza de una persona
72also look at how we manage environment variables for secrets.81* La variable de entorno que necesitan tus pruebas de integración
73```
74 82
75**2. Planificar**83También hay información que *sí* está en el repositorio pero que requiere unos minutos de búsqueda para encontrarla, y Claude tiene que repetir esa búsqueda al inicio de cada sesión.
76 84
77Pida a Claude que cree un plan de implementación detallado.85Una buena prueba antes de escribir cualquier cosa para Claude:
78 86
79```txt title="claude (plan mode)" wrap theme={null}871. ¿Podría encontrarlo leyendo el código?
80I want to add Google OAuth. What files need to change?882. ¿Realmente iría a buscarlo?
81What's the session flow? Create a plan.
82```
83 89
84Presione `Ctrl+G` para abrir el plan en su editor de texto para edición directa antes de que Claude continúe.90Si ambas respuestas son sí, déjalo fuera.
85 91
86**3. Implementar**92### Escribe un prompt específico
87 93
88Salga de plan mode aprobando el plan o presionando `Shift+Tab`, luego deje que Claude codifique, verificando contra su plan.94Un prompt específico ayuda por la misma razón, porque le da a Claude información que todavía no tiene. Si nombras el archivo, describes el síntoma y dices desde el principio cómo se ve "corregido", normalmente te ahorras una ronda de correcciones más adelante.
89 95
90```txt title="claude" wrap theme={null}96Lo mismo aplica a una preferencia entre dos enfoques razonables: Claude no puede leerla en el código, así que si te importa cuál elige, dilo desde el principio.
91implement the OAuth flow from your plan. write tests for the
92callback handler, run the test suite and fix any failures.
93```
94 97
95**4. Confirmar**98| En lugar de | Prueba |
99| :- | :- |
100| *"corrige el error de inicio de sesión"* | *"los usuarios informan que el inicio de sesión falla después de que la sesión expira. revisa la actualización de tokens en src/auth/, escribe una prueba fallida que lo reproduzca y luego corrígelo"* |
101| *"agrega un widget de calendario"* | *"sigue el patrón de HotDogWidget.php y crea un widget de calendario que permita elegir un mes y pasar entre años. sin bibliotecas nuevas"* |
96 102
97Pida a Claude que confirme con un mensaje descriptivo y cree un PR.103Si ya tienes lo que Claude necesita, entrégaselo en lugar de describirlo:
98 104
99```txt title="claude" wrap theme={null}105* Un archivo: escribe `@` y la ruta para [incluir el contenido del archivo](https://code.claude.com/docs/es/common-workflows.md#reference-files-and-directories) en tu mensaje.
100commit with a descriptive message and open a PR106* Una imagen: pega en el prompt la captura de pantalla del diseño o del error.
101```107* Salida de un comando: canalízala desde tu shell con `cat error.log | claude -p "what's going on here"`.
102 108
103Plan mode es útil, pero también agrega sobrecarga.109Frases como `think step by step` o `be thorough` son texto de prompt normal, no palabras clave. El control principal de cuánto piensa Claude es el [nivel de esfuerzo](https://code.claude.com/docs/es/model-config.md#adjust-effort-level), que se trata en [Cambia el modelo y el esfuerzo](#change-the-model-and-effort). Ese tipo de redacción aún puede empujar a Claude dentro de su ajuste de esfuerzo, pero no lo elevará por encima de él.
104 110
105Para tareas donde el alcance es claro y la corrección es pequeña (como corregir un error tipográfico, agregar una línea de registro o renombrar una variable) pida a Claude que lo haga directamente.111Una frase que sí sigue ayudando es `be ambitious`. Claude tiende a leer una petición de forma conservadora y a construir lo mínimo que la satisface, ya que no puede ver cuánto esperabas. Cuando quieras la versión más completa, con los casos extremos resueltos y la continuación natural incluida, dilo:
106 112
107La planificación es más útil cuando no está seguro del enfoque, cuando el cambio modifica múltiples archivos o cuando no está familiarizado con el código que se está modificando. Si pudiera describir el diff en una oración, omita el plan.113```text theme={null}
114build the settings page from the mockup. be ambitious: empty and error states, the save flow wired up, keyboard navigation, not just the layout
115```
108 116
109***117Eso le dice a Claude el alcance, que solo tú conoces, en lugar de cuánto pensar.
110 118
111## Proporcione contexto específico en sus indicaciones119Y cuando estás explorando en lugar de corregir algo específico, un prompt vago como `what would you improve in this file?` está completamente bien. Corregirás un poco más sobre la marcha, y esa es la contrapartida.
112 120
113> [!TIP]121### Haz una lluvia de ideas con Claude primero
114>
115> Cuanto más precisas sean sus instrucciones, menos correcciones necesitará.
116 122
117Claude puede inferir intención, pero no puede leer su mente. Haga referencia a archivos específicos, mencione restricciones y señale patrones de ejemplo.123Cuando todavía no sabes exactamente lo que quieres, no tienes que resolverlo todo antes de escribir el prompt. En su lugar, pídele a Claude que te entreviste:
118 124
119| Estrategia | Antes | Después |125```text theme={null}
120| - | - | - |126I want to add rate limiting to the public API but haven't thought it through yet. Interview me until you could write the spec, then write it to SPEC.md.
121| **Delimitar la tarea.** Especifique qué archivo, qué escenario y preferencias de prueba. | *"agregar pruebas para foo.py"* | *"escribir una prueba para foo.py cubriendo el caso extremo donde el usuario ha cerrado sesión. evitar mocks."* |127```
122| **Señalar fuentes.** Dirija a Claude a la fuente que puede responder una pregunta. | *"¿por qué ExecutionFactory tiene una API tan extraña?"* | *"revisar el historial de git de ExecutionFactory y resumir cómo su API llegó a ser así"* |
123| **Hacer referencia a patrones existentes.** Señale a Claude los patrones en su código base. | *"agregar un widget de calendario"* | *"ver cómo se implementan los widgets existentes en la página de inicio para entender los patrones. HotDogWidget.php es un buen ejemplo. seguir el patrón para implementar un nuevo widget de calendario que permita al usuario seleccionar un mes y paginar hacia adelante/atrás para elegir un año. construir desde cero sin bibliotecas que no sean las ya utilizadas en el código base."* |
124| **Describir el síntoma.** Proporcione el síntoma, la ubicación probable y qué significa "corregido". | *"corregir el error de inicio de sesión"* | *"los usuarios informan que el inicio de sesión falla después del agotamiento de la sesión. verificar el flujo de autenticación en src/auth/, especialmente la actualización de tokens. escribir una prueba fallida que reproduzca el problema, luego corregirlo"* |
125 128
126Las indicaciones vagas pueden ser útiles cuando está explorando y puede permitirse corregir el curso. Una indicación como `"¿qué mejoraría en este archivo?"` puede revelar cosas en las que no habría pensado en preguntar.129Claude vuelve con preguntas de opción múltiple sobre las partes que no has definido: límites por usuario o por clave, qué ocurre con las solicitudes que superan el límite, qué queda fuera del alcance. Sigue preguntando hasta que las respuestas formen una especificación.
127 130
128### Proporcionar contenido enriquecido131Una vez que `SPEC.md` exista, inicia una sesión nueva para construir a partir de ella, de modo que la construcción empiece con un contexto limpio y una definición escrita de terminado. También es el archivo al que dirigirás al revisor más adelante, en [Dale a Claude una verificación que ejecutar](#give-claude-a-check-to-run).
129 132
130> [!TIP]133### Mantén CLAUDE.md corto
131>
132> Use `@` para hacer referencia a archivos, pegue capturas de pantalla/imágenes o canalice datos directamente.
133 134
134Puede proporcionar datos enriquecidos a Claude de varias maneras:135Claude Code carga [`CLAUDE.md`](https://code.claude.com/docs/es/memory) en cada sesión, lo que significa que cada línea ocupa un poco de la atención de Claude en *cada* tarea, sea relevante o no. Por eso el archivo funciona mejor cuando solo contiene lo que Claude no podría deducir del propio código:
135 136
136* **Haga referencia a archivos con `@`** en lugar de describir dónde vive el código. Claude lee el archivo antes de responder.137* Cómo confirmar el trabajo en este repositorio: los comandos exactos de pruebas, verificación de tipos y lint, y cómo ejecutar un único archivo de pruebas
137* **Pegue imágenes directamente**. Copie/pegue o arrastre y suelte imágenes en la indicación.138* Lugares donde el código es engañoso: un patrón antiguo que está en todas partes pero que el código nuevo no debe copiar, o un directorio que parece sin uso pero no lo está
138* **Proporciona URLs** para documentación y referencias de API. Usa `/permissions` para agregar a la lista de permitidos los dominios de uso frecuente.139* Decisiones que no están en el repositorio: qué helper de errores eligió el equipo, cómo funcionan los despliegues, qué necesita una revisión de migración
139* **Canaliza datos** ejecutando `cat error.log | claude -p "explain this error"` para enviar el contenido de archivos directamente.140* Cualquier cosa que ya hayas tenido que corregir dos veces
140* **Deje que Claude obtenga lo que necesita**. Diga a Claude que extraiga contexto por sí mismo usando comandos Bash, herramientas MCP o leyendo archivos.
141 141
142***142Un `CLAUDE.md` que pasa esa prueba se mantiene corto:
143 143
144## Configura tu entorno144```markdown CLAUDE.md theme={null}
145# Commands
146- Install: pnpm install
147- Run one test file: pnpm vitest run path/to/file.test.ts
148- Typecheck: pnpm tsc --noEmit
145 149
146Algunos pasos de configuración hacen que Claude Code sea significativamente más efectivo en todas tus sesiones. Para una descripción completa de las características de la extensión y cuándo usar cada una, consulta [Extend Claude Code](https://code.claude.com/docs/es/features-overview.md).150# Conventions
151- Use the error helpers in src/lib/errors.ts, never throw raw strings
152- src/legacy/ is still live but don't copy its patterns into new code
147 153
148### Escribe un CLAUDE.md efectivo154# Gotchas
155- Integration tests need DATABASE_URL set, see .env.example
156```
149 157
150> [!TIP]158En una sesión, ejecuta `/context` para confirmar que Claude cargó el archivo.
151>
152> Ejecuta `/init` para generar un archivo CLAUDE.md inicial basado en la estructura actual de tu proyecto, luego refina con el tiempo.
153 159
154CLAUDE.md es un archivo especial que Claude lee al inicio de cada conversación. Incluye comandos Bash, estilo de código y reglas de flujo de trabajo. Esto le da a Claude un contexto persistente que no puede inferir solo del código.160Observa que la línea de verificación de tipos es solo el comando. Claude necesita conocer el comando para poder verificar su propio trabajo sobre la marcha. Si además quieres que Claude Code *exija* que la verificación de tipos pase antes de que Claude termine, eso es tarea de un [hook `Stop`](#enforce-the-check-with-a-stop-hook). Una línea como `Always typecheck before you finish` en este archivo funciona la mayoría de las veces, no siempre.
155 161
156No hay un formato requerido para los archivos CLAUDE.md, pero mantenlos cortos y legibles para humanos. Por ejemplo:162No tienes que escribir el archivo desde cero:
157 163
158```markdown CLAUDE.md theme={null}164* `/init` genera una versión inicial a partir de tu base de código. A partir de ahí, el trabajo consiste sobre todo en eliminar líneas. La [guía de memoria](https://code.claude.com/docs/es/memory.md#write-effective-instructions) recomienda mantenerse por debajo de 200.
159# Code style165* `/doctor` sugiere recortes para todo lo que Claude ya puede [deducir del código](https://code.claude.com/docs/es/memory.md#my-claude-md-is-too-large).
160- Use ES modules (import/export) syntax, not CommonJS (require)166* `/doctor prompt-audit` marca las instrucciones que se escribieron para modelos anteriores, que apuntan a archivos que ya no existen o que [se contradicen entre sí](https://code.claude.com/docs/es/memory.md#audit-your-instruction-files).
161- Destructure imports when possible (eg. import { foo } from 'bar')
162 167
163# Workflow168Tus preferencias personales van en `CLAUDE.local.md` en lugar de `CLAUDE.md`, y agregas ese archivo a `.gitignore` para que quede fuera del repositorio.
164- Be sure to typecheck when you're done making a series of code changes
165- Prefer running single tests, and not the whole test suite, for performance
166```
167 169
168Ejecuta `/context` para confirmar que Claude cargó el archivo. CLAUDE.md se carga en cada sesión, así que solo incluye cosas que se apliquen ampliamente. Para conocimiento de dominio o flujos de trabajo que solo son relevantes a veces, usa [skills](https://code.claude.com/docs/es/skills.md) en su lugar. Claude los carga bajo demanda sin saturar cada conversación.170> [!NOTE]
171>
172> Si Claude sigue ignorando una línea que *sí* está en `CLAUDE.md`, agregar IMPORTANT probablemente no lo arreglará. O bien el archivo ha crecido tanto que la línea se pierde, o bien la línea es una regla que no puede tener excepciones, en cuyo caso debería ser un [hook](#enforce-the-rules-that-cant-have-exceptions).
169 173
170Mantenlo conciso. Para cada línea, pregúntate: *"¿Causaría que Claude cometa errores si elimino esto?"* Si no, elimínalo. Los archivos CLAUDE.md inflados hacen que Claude ignore tus instrucciones reales.174### Limita las reglas a una parte de la base de código
171 175
172| ✅ Incluir | ❌ Excluir |176Si una regla solo importa en una parte de la base de código, ponla en [`.claude/rules/`](https://code.claude.com/docs/es/memory#path-specific-rules) con un filtro `paths:` para que solo se cargue cuando Claude realmente esté trabajando allí. Por ejemplo, este `.claude/rules/api.md` se carga para los archivos TypeScript bajo `src/api/`:
173| - | - |
174| Comandos Bash que Claude no puede adivinar | Cualquier cosa que Claude pueda descubrir leyendo código |
175| Reglas de estilo de código que difieren de los valores predeterminados | Convenciones de lenguaje estándar que Claude ya conoce |
176| Instrucciones de prueba y ejecutores de prueba preferidos | Documentación detallada de API (enlaza a documentos en su lugar) |
177| Etiqueta del repositorio (nomenclatura de ramas, convenciones de PR) | Información que cambia frecuentemente |
178| Decisiones arquitectónicas específicas de tu proyecto | Explicaciones largas o tutoriales |
179| Peculiaridades del entorno de desarrollo (variables de entorno requeridas) | Descripciones archivo por archivo de la base de código |
180| Errores comunes o comportamientos no obvios | Prácticas evidentes como "escribir código limpio" |
181 177
182Si Claude sigue haciendo algo que no quieres a pesar de tener una regla en contra, el archivo probablemente es demasiado largo y la regla se está perdiendo. Si Claude te hace preguntas que están respondidas en CLAUDE.md, la redacción podría ser ambigua. Trata CLAUDE.md como código: revísalo cuando las cosas salgan mal, pódalo regularmente y prueba cambios observando si el comportamiento de Claude realmente cambia. Para un CLAUDE.md registrado, ejecuta [`/doctor`](https://code.claude.com/docs/es/commands#all-commands) y Claude propone cortes para contenido que puede derivar de la base de código.178```markdown .claude/rules/api.md theme={null}
179---
180paths:
181 - "src/api/**/*.ts"
182---
183- Validate request bodies with the zod schemas in src/api/schemas/, don't hand-roll checks
184- Every new endpoint needs an entry in openapi.yaml, CI fails without it
185```
183 186
184Si Claude sigue omitiendo una instrucción, añade énfasis como "IMPORTANTE" solo a esa línea. Si enfatizas muchas líneas, ninguna destaca. Registra CLAUDE.md en git para que tu equipo pueda contribuir. El archivo aumenta en valor con el tiempo.187### Pon los procedimientos del equipo en skills
185 188
186Los archivos CLAUDE.md pueden importar archivos adicionales usando la sintaxis `@path/to/import`. Para reglas de importación y dónde pueden vivir los archivos CLAUDE.md, consulta [CLAUDE.md files](https://code.claude.com/docs/es/memory.md#claude-md-files).189Un modelo más capaz sabe más sobre ingeniería, pero no cómo hace *tu* equipo un lanzamiento, qué dice tu runbook de incidentes o cómo quieres que se escriba la documentación de la API. Ese tipo de conocimiento va en un [skill](https://code.claude.com/docs/es/skills.md): un procedimiento o un conocimiento del equipo guardado en `.claude/skills/<name>/SKILL.md`.
187 190
188### Configura permisos191Los skills también consumen menos contexto que `CLAUDE.md` para este tipo de cosas. Para un skill que Claude puede iniciar por sí mismo, ve el nombre y la descripción en cada sesión, pero solo [lee el archivo completo](https://code.claude.com/docs/es/skills.md#skill-content-lifecycle) cuando la tarea lo requiere. Un procedimiento de lanzamiento largo dentro de un skill no pesa sobre tu corrección de un error no relacionado como lo haría en `CLAUDE.md`.
189 192
190> [!TIP]193> [!NOTE]
191>194>
192> Para obtener menos solicitudes sin renunciar al control, pre-aprueba las herramientas en las que confías con `/permissions` y deja que los comandos en sandbox se ejecuten sin preguntar con `/sandbox`. Cambia a modo Manual cuando quieras aprobar ediciones y comandos tú mismo.195> La regla de `CLAUDE.md` también se aplica a los skills: escribe solo lo que Claude no puede encontrar por sí mismo.
193 196
194Con Claude Code v2.1.283 o posterior, el modo automático es el [modo de permiso inicial integrado](https://code.claude.com/docs/es/permission-modes.md#eliminate-prompts-with-auto-mode) para sesiones interactivas de terminal y VS Code: un modelo clasificador separado revisa la mayoría de acciones en lugar de ti y bloquea solo lo que parece arriesgado, como escalada de alcance, infraestructura desconocida o acciones impulsadas por contenido hostil. En versiones anteriores, el modo automático es el modo de permiso inicial integrado solo en planes Pro, Max y Team.197Para un flujo de trabajo con efectos secundarios, como hacer realmente ese lanzamiento, agrega `disable-model-invocation: true`. Así Claude [no puede iniciar el skill por sí mismo](https://code.claude.com/docs/es/skills.md#control-who-invokes-a-skill), y solo se ejecuta cuando tú escribes `/release`. Guardado como `.claude/skills/release/SKILL.md`, podría verse así:
195 198
196En modo Manual, Claude Code pregunta antes de acciones que podrían modificar tu sistema: escrituras de archivos, comandos Bash, herramientas MCP. Eso es seguro pero tedioso. Después de la décima aprobación estás haciendo clic sin revisar realmente. Dos herramientas reducen esas interrupciones en modo Manual y se aplican también en modo automático:199```markdown .claude/skills/release/SKILL.md theme={null}
200---
201name: release
202description: Cut a new release. Bumps the version, writes the changelog entry, tags it and pushes the tag so CI can publish.
203disable-model-invocation: true
204---
2051. Make sure you're on main with a clean tree. If not, stop and ask.
2062. Run `pnpm changeset version` and commit the result.
2073. Summarize the PRs merged since the last tag into CHANGELOG.md, one line each, user-facing changes only.
2084. Tag `v<new version>` and push the tag. CI publishes from there, never publish from your machine.
209```
197 210
198* **Listas de permisos**: permiten herramientas específicas que sabes que son seguras, como `npm run lint` o `git commit`211### Conecta las herramientas que Claude necesita
199* **Sandboxing**: habilita aislamiento a nivel del SO que restringe el acceso al sistema de archivos y red, permitiendo que Claude trabaje más libremente dentro de límites definidos
200 212
201Lee más sobre [permission modes](https://code.claude.com/docs/es/permission-modes.md), [permission rules](https://code.claude.com/docs/es/permissions.md) y [sandboxing](https://code.claude.com/docs/es/sandboxing.md).213Parte de lo que Claude no puede ver vive en otro sistema por completo, como tu gestor de incidencias o tu panel de errores. Si ese sistema tiene un CLI, normalmente es la forma más fácil de acceder. Con `gh` instalado y con la sesión iniciada, por ejemplo, Claude abrirá pull requests y leerá comentarios de revisión sin ninguna explicación de tu parte. Para un CLI que no ha visto antes, basta con indicarle `--help`.
202 214
203### Usa herramientas CLI215Para los sistemas sin CLI, existe [MCP](https://code.claude.com/docs/es/mcp.md). Agregas un servidor desde tu shell:
204 216
205> [!TIP]217```bash theme={null}
206>218claude mcp add --transport http notion https://mcp.notion.com/mcp
207> Dile a Claude Code que use herramientas CLI como `gh`, `aws`, `gcloud` y `sentry-cli` cuando interactúe con servicios externos.219```
220
221Luego el servidor aparece en `/mcp` dentro de una sesión. Los servidores conectados agregan sus nombres de herramientas e instrucciones al contexto incluso cuando no los estás usando, así que vale la pena [desactivar allí los que no necesitas](https://code.claude.com/docs/es/mcp.md#disable-a-server-without-removing-it).
222
223Y si trabajas en un lenguaje tipado, un [plugin de inteligencia de código](https://code.claude.com/docs/es/plugins/code-intelligence.md) permite que Claude salte directamente a una definición en lugar de leer muchos archivos para encontrarla.
208 224
209Las herramientas CLI son la forma más eficiente en contexto de interactuar con servicios externos. Si usas GitHub, instala el CLI `gh`. Claude sabe cómo usarlo para crear problemas, abrir solicitudes de extracción y leer comentarios. Sin `gh`, Claude aún puede usar la API de GitHub, pero las solicitudes no autenticadas a menudo alcanzan límites de velocidad.225## Dale a Claude una verificación que ejecutar
210 226
211Claude también es efectivo aprendiendo herramientas CLI que no conoce. Intenta solicitudes como `Use 'foo-cli-tool --help' to learn about foo tool, then use it to solve A, B, C.`227Claude se detiene cuando el trabajo parece terminado. Si no tiene nada que ejecutar que le diga si el trabajo realmente *está* terminado, "parece terminado" es lo único en lo que puede basarse. En la práctica, eso te convierte a ti en el conjunto de pruebas, y cada error se queda ahí hasta que lo notes por casualidad.
212 228
213### Conecta servidores MCP229Si le das algo que devuelva aprobado o fallido, Claude puede cerrar ese ciclo por sí mismo. Hace el cambio, ejecuta la verificación y, si algo se rompió, lee la salida y lo corrige antes de volver a ejecutar la verificación.
214 230
215> [!TIP]231> [!TIP]
216>232>
217> Ejecuta `claude mcp add` con un nombre de servidor y URL o comando para conectar herramientas externas como Notion, Figma o tu base de datos. Por ejemplo: `claude mcp add --transport http notion https://mcp.notion.com/mcp`.233> Dale a Claude algo que pueda ejecutar y que devuelva aprobado o fallido. Una vez que lo tenga, puede seguir trabajando por su cuenta y no tienes que estar observando.
218 234
219Con [MCP servers](https://code.claude.com/docs/es/mcp.md), puedes pedirle a Claude que implemente características de rastreadores de problemas, consulte bases de datos, analice datos de monitoreo, integre diseños de Figma y automatice flujos de trabajo.235La verificación puede ser casi cualquier cosa, siempre que Claude pueda leer el resultado:
220 236
221### Configura hooks237* Un archivo de pruebas
238* El código de salida de una compilación
239* Un linter
240* Un script que compara la salida con una fixture
241* Una [captura de pantalla del navegador](https://code.claude.com/docs/es/chrome.md) junto al diseño
222 242
223> [!TIP]243Si tu repositorio ya tiene alguna de estas, la línea más útil de tu `CLAUDE.md` es el comando que la ejecuta.
224>
225> Usa hooks para acciones que deben ocurrir cada vez sin excepciones.
226 244
227[Hooks](https://code.claude.com/docs/es/hooks-guide.md) ejecutan scripts automáticamente en puntos específicos del flujo de trabajo de Claude. A diferencia de las instrucciones CLAUDE.md que son consultivas, los hooks son deterministas y garantizan que la acción ocurra.245Qué tan estricta hagas la verificación depende de ti. Las opciones van desde que Claude decida por sí mismo hasta que Claude Code la exija:
228 246
229Claude puede escribir hooks para ti. Intenta solicitudes como *"Write a hook that runs eslint after every file edit"* o *"Write a hook that blocks writes to the migrations folder."* Edita `.claude/settings.json` directamente para configurar hooks manualmente, y ejecuta `/hooks` para explorar lo que está configurado.247* En el prompt: `run the auth tests after, and keep going until they pass`. Claude decide por sí mismo cuándo está satisfecho. Esto funciona para cualquier tarea, hoy mismo, sin configuración.
248* Como objetivo: [`/goal all tests in tests/auth pass and lint is clean`](https://code.claude.com/docs/es/goal) establece una condición que un modelo separado verifica contra la conversación después de cada turno, y Claude sigue trabajando hasta que se cumple. Rara vez lo necesitas tú mismo en la sesión. Importa en ejecuciones largas en segundo plano, donde Claude a veces termina un turno con un resumen del progreso mientras aún quedan elementos pendientes, y el objetivo lo hace volver al trabajo.
249* Como hook Stop: un [hook `Stop`](https://code.claude.com/docs/es/hooks#stop) ejecuta tu script cada vez que Claude intenta terminar su turno, y devuelve a Claude al trabajo si el script sale con el código 2. Este lo aplica Claude Code (el harness), así que el turno no termina hasta que pase la verificación de tipos o se alcance el [límite de bloqueos](https://code.claude.com/docs/es/hooks.md#stop-input). Hay un [ejemplo más abajo](#enforce-the-check-with-a-stop-hook).
250* Por alguien que no escribió el código: en la terminal, [`/code-review`](https://code.claude.com/docs/es/code-review-local) revisa el diff en un subagente nuevo que nunca vio tu conversación. No se deja influir por el razonamiento que produjo el código.
230 251
231### Crea skills252Sea cual sea la opción que uses, pídele a Claude *evidencia*: el comando que ejecutó y su salida, o la captura de pantalla. "Todas las pruebas pasan" por sí solo te dice muy poco, y leer la salida es más rápido que volver a ejecutar la verificación tú mismo. Para una sesión que no estabas observando, también es la única evidencia que tienes.
232 253
233> [!TIP]254> [!TIP]
234>255>
235> Crea archivos `SKILL.md` en `.claude/skills/` para darle a Claude conocimiento de dominio y flujos de trabajo reutilizables.256> Una vez que Claude diga que terminó, también puedes ejecutar [`/verify`](https://code.claude.com/docs/es/skills#run-and-verify-your-app) en la sesión, lo que hace que Claude compile y ejecute la aplicación y revise el resultado. Eso detecta el tipo de problema que las pruebas y la verificación de tipos pasan por alto.
236 257
237[Skills](https://code.claude.com/docs/es/skills.md) extienden el conocimiento de Claude con información específica de tu proyecto, equipo o dominio. Claude los aplica automáticamente cuando son relevantes, o puedes invocarlos directamente con `/skill-name`.258### Revisa contra tu especificación
238 259
239Crea una skill añadiendo un directorio con un `SKILL.md` a `.claude/skills/`:260Si prefieres que la revisión compare el trabajo con tu plan en lugar de buscar errores en general, escribe tú mismo el prompt de revisión:
240 261
241```markdown .claude/skills/api-conventions/SKILL.md theme={null}262```text theme={null}
242name: api-conventions263use a subagent to review the rate limiter diff against SPEC.md, check every requirement is implemented and the listed edge cases have tests, report gaps that affect correctness and skip style
243description: REST API design conventions for our services
244# API Conventions
245- Use kebab-case for URL paths
246- Use camelCase for JSON properties
247- Always include pagination for list endpoints
248- Version APIs in the URL path (/v1/, /v2/)
249```264```
250 265
251Las skills también pueden definir flujos de trabajo repetibles que invocas directamente:266> [!NOTE]
252 267>
253```markdown .claude/skills/fix-issue/SKILL.md theme={null}268> No quites la parte `skip style` de ese prompt. Un revisor al que se le pide encontrar problemas siempre encontrará *algo*. Si corriges cada hallazgo, terminas con capas de abstracción adicionales y pruebas para casos que no pueden ocurrir.
254name: fix-issue269
255description: Fix a GitHub issue270### Exige la verificación con un hook Stop
256disable-model-invocation: true271
257Analyze and fix the GitHub issue: $ARGUMENTS.272La versión con hook `Stop` de la regla de verificación de tipos son unas pocas líneas en `.claude/settings.json`. El código de salida 2 es lo que bloquea la detención. Lo que el comando imprima en stderr vuelve a Claude como la razón por la que aún no puede terminar, por eso la salida del compilador se redirige allí:
258 273
2591. Use `gh issue view` to get the issue details274```json .claude/settings.json theme={null}
2602. Understand the problem described in the issue275{
2613. Search the codebase for relevant files276 "hooks": {
2624. Implement the necessary changes to fix the issue277 "Stop": [
2635. Write and run tests to verify the fix278 {
2646. Ensure code passes linting and type checking279 "hooks": [
2657. Create a descriptive commit message280 { "type": "command", "command": "pnpm tsc --noEmit 1>&2 || exit 2" }
2668. Push and create a PR281 ]
282 }
283 ]
284 }
285}
267```286```
268 287
269Ejecuta `/fix-issue 1234` para invocarlo. Usa `disable-model-invocation: true` para flujos de trabajo con efectos secundarios que quieres activar manualmente.288Para verlo funcionar, pídele a Claude un cambio que rompa un tipo: en lugar de terminar, recibe los errores del compilador y sigue trabajando hasta que `tsc` pase. Si el hook bloquea [ocho detenciones seguidas](https://code.claude.com/docs/es/hooks.md#stop-input) sin ninguna llamada a herramienta entre ellas, Claude Code sobrescribe el siguiente bloqueo y termina el turno. Para aumentar el límite, establece [`CLAUDE_CODE_STOP_HOOK_BLOCK_CAP`](https://code.claude.com/docs/es/env-vars).
270 289
271### Crea subagentes personalizados290## Aplica las reglas que no pueden tener excepciones
272 291
273> [!TIP]292> [!TIP]
274>293>
275> Define asistentes especializados en `.claude/agents/` que Claude pueda delegar para tareas aisladas.294> Si algo tiene que ocurrir siempre, conviértelo en un hook, una regla de denegación o una configuración administrada. `CLAUDE.md` es para pautas, y Claude puede decidir que una pauta no aplica.
276 295
277[Subagents](https://code.claude.com/docs/es/sub-agents.md) se ejecutan en su propio contexto con su propio conjunto de herramientas permitidas. Son útiles para tareas que leen muchos archivos o necesitan enfoque especializado sin saturar tu conversación principal.296Toma tres reglas que podrías tener hoy en `CLAUDE.md`: `Never read .env`, `Always run the formatter after editing`, `Don't touch the migrations folder`. Claude las seguirá casi siempre. Para las pocas en las que "casi" no es suficiente, sácalas de `CLAUDE.md` y pásalas a una configuración que Claude Code (el harness) aplica por sí mismo. A partir de entonces, el resultado no depende de lo que el modelo recuerde o decida.
278 297
279```markdown .claude/agents/security-reviewer.md theme={null}298### Exige pasos con hooks
280name: security-reviewer299
281description: Reviews code for security vulnerabilities300Los [hooks](https://code.claude.com/docs/es/hooks-guide.md) ejecutan algo tuyo en puntos fijos del ciclo de Claude: antes o después de una llamada a herramienta, cuando Claude intenta detenerse, cuando comienza una sesión, etc. Ese algo puede ser:
282tools: Read, Grep, Glob, Bash301
283model: opus302* Un comando de shell (el caso habitual)
284You are a senior security engineer. Review code for:303* Un POST a un endpoint HTTP
285- Injection vulnerabilities (SQL, XSS, command injection)304* Una llamada a herramienta en uno de tus servidores MCP
286- Authentication and authorization flaws305* Un [hook `prompt` o `agent`](https://code.claude.com/docs/es/hooks#hook-handler-fields), que deja que un modelo decida
287- Secrets or credentials in code306
288- Insecure data handling307Un hook `prompt` o `agent` le pide a *otro modelo* que decida, así que tampoco es determinista. Para una aplicación real, usa un hook `command` o `http`, y agrega [`onFailure: "block"`](https://code.claude.com/docs/es/hooks#block-the-action-when-a-hook-fails) si la acción también debe detenerse cuando el propio hook falla o agota el tiempo de espera. Para un hook que analiza commits en busca de secretos, por ejemplo, preferirías bloquear el commit antes que dejarlo pasar sin analizar mientras el escáner está caído.
308
309Aquí está la regla del formateador como un hook `PostToolUse`. Se ejecuta después de cada `Edit` o `Write`, y ya no importa si Claude recuerda la regla, porque no es Claude quien la ejecuta:
289 310
290Provide specific line references and suggested fixes.311```json .claude/settings.json theme={null}
312{
313 "hooks": {
314 "PostToolUse": [
315 {
316 "matcher": "Edit|Write",
317 "hooks": [
318 { "type": "command", "command": "npx prettier --write --ignore-unknown \"$(jq -r '.tool_input.file_path')\"" }
319 ]
320 }
321 ]
322 }
323}
291```324```
292 325
293Dile a Claude que use subagentes explícitamente: *"Use a subagent to review this code for security issues."*326Para comprobar el hook, pídele a Claude que agregue una línea mal indentada a un archivo que Prettier formatea. El archivo guardado vuelve con la indentación corregida.
294 327
295### Instala plugins328La regla de migraciones se convierte en un [hook `PreToolUse`](https://code.claude.com/docs/es/hooks-guide#block-edits-to-protected-files) que sale con el código 2 para cualquier ruta bajo `migrations/`. No tienes que escribirlo tú mismo: `write a hook that blocks edits to the migrations folder` funciona como prompt, y `/hooks` muestra el resultado. Pero no te excedas: un hook es para una regla con *cero* excepciones, y `Prefer named exports` tiene muchas, así que esa se queda en `CLAUDE.md`.
296 329
297> [!TIP]330### Limita el acceso con reglas de permisos y el sandbox
298>
299> Ejecuta `/plugin` para explorar el marketplace. Los plugins añaden skills, herramientas e integraciones sin configuración.
300 331
301[Plugins](https://code.claude.com/docs/es/plugins/overview.md) agrupan skills, hooks, subagentes y servidores MCP en una única unidad instalable de la comunidad y Anthropic. Si trabajas con un lenguaje tipado, instala un [code intelligence plugin](https://code.claude.com/docs/es/plugins/code-intelligence.md) para darle a Claude navegación de símbolos precisa y detección automática de errores después de ediciones.332Las [reglas de permisos](https://code.claude.com/docs/es/permissions.md) deciden qué puede ejecutar, leer y obtener Claude. Las reglas `deny` se mantienen en todos los modos de permisos, incluidos el automático y `bypassPermissions`, y precisamente por eso la regla de `.env` va ahí:
302 333
303Para orientación sobre cómo elegir entre skills, subagentes, hooks y MCP, consulta [Extend Claude Code](https://code.claude.com/docs/es/features-overview.md#match-features-to-your-goal).334```json .claude/settings.json theme={null}
335{
336 "permissions": {
337 "allow": ["Bash(pnpm tsc --noEmit)"],
338 "ask": ["Bash(git push *)"],
339 "deny": ["Read(./.env)", "Read(./.env.local)", "Read(./secrets/**)"]
340 }
341}
342```
304 343
305***344Con esto guardado, preguntarle a Claude qué hay en `.env` falla, tanto con la herramienta `Read` como con `cat .env`.
306 345
307## Comuníquese efectivamente346Las reglas coinciden con llamadas a herramientas, no con intenciones, así que conviene saber dónde están los límites:
308 347
309Haga a Claude las preguntas que haría a otro ingeniero, y para características más grandes, deje que Claude lo entreviste y escriba una especificación antes de que comience a implementar.348* La regla `Read` *sí* detecta `cat .env`, porque Claude Code reconoce los [comandos comunes de lectura de archivos](https://code.claude.com/docs/es/permissions.md#read-and-edit).
349* No detectará un script que abra el archivo.
350* Una regla de denegación de `WebFetch` para un dominio no hace nada contra `curl` a ese mismo dominio, a menos que el sandbox esté activado.
310 351
311### Haga preguntas sobre el código base352Para un límite a nivel del sistema operativo sobre el acceso al sistema de archivos o a la red, activa el [sandbox](https://code.claude.com/docs/es/sandboxing.md) con `/sandbox` en una sesión. Confina los comandos de shell de Claude en macOS, Linux y WSL2 y también [incorpora tus reglas de denegación de `Read` y tus reglas `WebFetch(domain:...)`](https://code.claude.com/docs/es/sandboxing#permission-rules), así que para cualquier cosa relacionada con la seguridad quieres ambos.
312 353
313> [!TIP]354De forma predeterminada, Claude aún puede pedir reintentar un comando bloqueado fuera del sandbox, y esa petición pasa por el flujo normal de permisos. El [modo estricto del sandbox](https://code.claude.com/docs/es/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode), en la pestaña **Overrides** de `/sandbox`, desactiva ese reintento.
355
356> [!WARNING]
314>357>
315> Haga a Claude preguntas que haría a un ingeniero senior.358> El modo automático es un modelo clasificador que juzga cada acción, no una regla rígida. Lo hace bien, pero como cualquier juicio, puede equivocarse. Además, puedes ajustar lo que considera arriesgado, y tu organización puede desactivarlo por completo, así que tus reglas de "nunca" deben estar en reglas de denegación o en hooks.
359
360### Elige a quién se aplica una regla
316 361
317Al incorporarse a un nuevo código base, use Claude Code para aprender y explorar. Puede hacer a Claude el mismo tipo de preguntas que haría a otro ingeniero:362Dónde vive una regla decide a quién se aplica:
318 363
319* ¿Cómo funciona el registro?364* `.claude/settings.local.json` y `~/.claude/settings.json` son solo tuyos. Cuando seleccionas **Yes, and don't ask again** para un comando, Claude Code guarda esa regla en el archivo local.
320* ¿Cómo hago un nuevo punto final de API?365* `.claude/settings.json` y los hooks que contiene pertenecen al repositorio. Una vez que haces commit de ellos, se aplican a todos los que trabajan en el repositorio. Sus reglas de denegación se aplican de inmediato. Sus reglas `allow` esperan hasta que cada persona acepta el [diálogo de confianza](https://code.claude.com/docs/es/permissions.md#what-runs-before-you-trust-a-folder) para esa carpeta, y la [confianza del espacio de trabajo](https://code.claude.com/docs/es/hooks.md#workspace-trust) también decide cuándo empiezan a ejecutarse sus hooks en su máquina.
321* ¿Qué hace `async move { ... }` en la línea 134 de `foo.rs`?366* La [configuración administrada](https://code.claude.com/docs/es/managed-settings.md) pertenece a la organización. Proviene de la consola de administración, de MDM o de un archivo `managed-settings.json`, y ningún archivo de configuración personal puede sobrescribirla, lo que la convierte en el único lugar para la política de un equipo de seguridad. Si eres la persona que la establece, consulta [Configura Claude Code para tu organización](https://code.claude.com/docs/es/admin-setup.md).
322* ¿Qué casos extremos maneja `CustomerOnboardingFlowImpl`?
323* ¿Por qué este código llama a `foo()` en lugar de `bar()` en la línea 333?
324 367
325Usar Claude Code de esta manera es un flujo de trabajo de incorporación efectivo, mejorando el tiempo de rampa y reduciendo la carga en otros ingenieros. No se requiere indicación especial: haga preguntas directamente.368Sea cual sea el alcance, mantén pequeño el conjunto de reglas aplicadas. Cada hook y regla de denegación se activará ocasionalmente cuando no debería, y alguien tiene que mantener cada uno. Si alguna vez te encuentras con cuarenta, la mayoría probablemente son preferencias que Claude podría haber sopesado por sí mismo.
326 369
327### Deje que Claude lo entreviste370## Cambia un valor predeterminado
328 371
329> [!TIP]372> [!TIP]
330>373>
331> Para características más grandes, deje que Claude lo entreviste primero. Comience con una indicación mínima y pida a Claude que lo entreviste usando la herramienta `AskUserQuestion`.374> Los valores predeterminados son lo bastante buenos como para dejarlos como están hasta que una tarea cueste más tiempo, tokens o interrupciones de lo que debería. Cuando eso ocurra, ejecuta `/usage` en la sesión para ver en qué se fue.
332 375
333Claude hace preguntas sobre cosas que podría no haber considerado, incluyendo implementación técnica, UI/UX, casos extremos y compensaciones. Reemplace `[brief description]` con su característica antes de enviar la indicación.376Una sesión nueva ya toma varias decisiones por ti:
334 377
335```text wrap theme={null}378* Las sesiones interactivas de terminal y VS Code comienzan en modo automático.
336I want to build [brief description]. Interview me in detail using the AskUserQuestion tool.379* Ejecuta [Claude Opus 5.5 con esfuerzo medio](https://code.claude.com/docs/es/model-config.md#default-model-setting) en la mayoría de los planes y proveedores.
380* Delega trabajo en subagentes cuando ve una razón para hacerlo.
381* Compacta la conversación a medida que crece.
337 382
338Ask about technical implementation, UI/UX, edge cases, concerns, and tradeoffs. Don't ask obvious questions, dig into the hard parts I might not have considered.383La mayor parte del tiempo nunca piensas en estas cosas. Cuando una tarea sí cuesta más de lo que debería, normalmente la causa es una de estas cuatro.
339 384
340Keep interviewing until we've covered everything, then write a complete spec to SPEC.md.385### Cambia el modo de permisos
341```
342 386
343Una vez que la especificación esté completa, inicie una sesión nueva para ejecutarla. La nueva sesión tiene contexto limpio enfocado completamente en la implementación, y tiene una especificación escrita para hacer referencia.387Ambos extremos del rango de permisos tienen un costo:
344 388
345Las especificaciones más útiles son autónomas: nombran los archivos e interfaces involucrados, establecen qué está fuera del alcance, y terminan con un paso de verificación de extremo a extremo que demuestra que la característica funciona. El tiempo dedicado a hacer la especificación precisa se compensa más que el tiempo dedicado a observar la implementación.389* **Modo Manual**: apruebas tú mismo cada edición y cada comando que no sea de solo lectura. Es seguro, pero después de la décima solicitud empiezas a aprobar sin leer, y nada avanza mientras estás lejos del teclado.
390* **`bypassPermissions`**: aprueba todo lo que tus reglas deny y ask no cubren, lo cual solo tiene sentido en un contenedor desechable.
346 391
347***392El [modo automático](https://code.claude.com/docs/es/permission-modes.md#eliminate-prompts-with-auto-mode) se sitúa entre ambos, y es el modo en el que [comienzan](https://code.claude.com/docs/es/permission-modes.md#which-mode-a-session-starts-in) las sesiones interactivas de terminal y VS Code. Claude trabaja sin detenerse para aprobaciones rutinarias, y un modelo clasificador separado revisa las acciones en [un orden fijo](https://code.claude.com/docs/es/permission-modes.md#how-the-classifier-evaluates-actions) antes de que se ejecuten. Se concentra en [las cosas que querrías que una persona detuviera](https://code.claude.com/docs/es/permission-modes.md#what-the-classifier-blocks-by-default):
348 393
349## Gestione su sesión394* `curl | bash`
395* Despliegues y migraciones a producción
396* Force pushes sobre el trabajo de otras personas
397* Datos sensibles enviados a endpoints externos
398* Acciones que parecen impulsadas por contenido que Claude leyó y no por ti
350 399
351Las conversaciones son persistentes y reversibles. ¡Úselo a su favor!400Cuando sí bloquea algo, recibes una notificación y la acción aparece en **Recently denied** en `/permissions`, donde puedes reintentarla con una aprobación manual. Después de [tres bloqueos seguidos](https://code.claude.com/docs/es/permission-modes.md#when-auto-mode-falls-back) (o veinte en total), el modo automático se pausa y vuelve a preguntarte.
352 401
353### Corrija el curso temprano y a menudo402Nada de esto reemplaza tus controles deterministas, porque se ejecuta *después* de ellos. Las reglas deny y ask y los hooks `PreToolUse` se aplican antes de que el clasificador vea nada, así que una regla de denegación bloquea en modo automático exactamente igual que en cualquier otro lugar. El sandbox sigue confinando los [comandos de shell que envuelve](https://code.claude.com/docs/es/sandboxing.md#what-runs-outside-the-sandbox).
354 403
355> [!TIP]404> [!NOTE]
356>405>
357> Corrija a Claude tan pronto como note que se desvía del camino.406> También puedes decir `don't push until I've reviewed` en la conversación, y el clasificador [lo trata como una señal de bloqueo](https://code.claude.com/docs/es/permission-modes.md#boundaries-you-state-in-conversation). Sigue siendo un modelo leyendo la transcripción, y la frase puede perderse cuando la conversación se compacta, así que cualquier cosa que importe debe estar en una regla de denegación.
407
408El problema opuesto es que el clasificador detenga repetidamente algo que es rutinario en tu entorno. En lugar de aprobarlo manualmente cada vez, agrégalo a `autoMode.allow` o describe tu infraestructura de confianza en la [configuración del modo automático](https://code.claude.com/docs/es/auto-mode-config.md). Está en inglés sencillo y no en patrones, y [`/auto-mode-setup`](https://code.claude.com/docs/es/auto-mode-config#generate-environment-entries) puede redactar la parte `environment` por ti a partir de tu proyecto y tus sesiones recientes:
409
410```json ~/.claude/settings.json theme={null}
411{
412 "autoMode": {
413 "environment": [
414 "$defaults",
415 "Source control: github.com/example-org and every repo under it",
416 "Trusted internal domains: *.internal.example.com"
417 ],
418 "allow": [
419 "$defaults",
420 "Deploying to the staging namespace is fine, it's isolated from production and resets nightly"
421 ]
422 }
423}
424```
358 425
359Los mejores resultados provienen de bucles de retroalimentación ajustados. Aunque Claude ocasionalmente resuelve problemas perfectamente en el primer intento, corregirlo rápidamente generalmente produce mejores soluciones más rápido.426> [!WARNING]
427>
428> Mantén `"$defaults"` en cada lista que establezcas, porque sin él tus entradas *reemplazan* las reglas integradas de esa lista en lugar de sumarse a ellas. Para `environment` y `allow` perderías el contexto y las excepciones integrados, y una lista `soft_deny` sin él elimina los bloqueos integrados sobre force pushes y despliegues a producción.
429>
430> El bloque `autoMode` también tiene que estar en `~/.claude/settings.json` y no en el proyecto, porque el clasificador ignora `autoMode` en la configuración del proyecto.
360 431
361* **`Esc`**: detener a Claude a mitad de acción con la tecla `Esc`. El contexto se preserva, para que pueda redirigir.432Si prefieres ver cada edición y comando antes de que ocurran, `Shift+Tab` en la sesión recorre los modos de permisos, incluido Manual, o empieza con `claude --permission-mode manual` desde tu shell. Y si Manual luego pregunta demasiado, `/fewer-permission-prompts` analiza tus transcripciones recientes en busca de llamadas comunes de solo lectura de Bash y MCP y las agrega a una lista de permitidos en `.claude/settings.json`.
362* **`Esc + Esc` o `/rewind`**: presione `Esc` dos veces o ejecute `/rewind` para abrir el menú de rebobinado y restaurar la conversación anterior y el estado del código, o resumir desde un mensaje seleccionado.
363* **`"Undo that"`**: haga que Claude revierta sus cambios.
364* **`/clear`**: restablecer contexto entre tareas no relacionadas. Las sesiones largas con contexto irrelevante pueden reducir el rendimiento.
365 433
366Si ha corregido a Claude más de dos veces en el mismo problema en una sesión, el contexto está saturado de enfoques fallidos. Ejecute `/clear` e inicie de nuevo con una indicación más específica que incorpore lo que aprendió. Una sesión limpia con una indicación mejor casi siempre supera una sesión larga con correcciones acumuladas.434### Cambia el modelo y el esfuerzo
367 435
368### Gestione el contexto agresivamente436El [esfuerzo](https://code.claude.com/docs/es/model-config.md#adjust-effort-level) es el control principal de cuánto tiempo piensa Claude, y reemplaza la mayor parte de lo que la gente solía hacer con la redacción del prompt. Claude Opus 5.5, Sonnet 5.5 y Haiku 5.5 usan `medium` de forma predeterminada, lo cual es suficiente para el trabajo cotidiano en funcionalidades con un alcance claro. Los momentos en que lo cambiarías, con `/effort` en la sesión:
369 437
370> [!TIP]438* Súbelo con `/effort high` o `/effort xhigh` cuando hacerlo bien dependa de casos fáciles de pasar por alto. Piensa en un error en código que no escribiste, una prueba inestable o un cambio de esquema en el que Claude tiene que encontrar cada lector de la forma antigua. Claude entonces revisa más casos extremos y verifica más de su trabajo antes de responder, y ahí es donde se van el tiempo y los tokens adicionales.
371>439* Bájalo con `/effort low` cuando estás yendo y viniendo rápidamente y revisando cada resultado de todos modos: lluvia de ideas, un primer boceto, un cambio de nombre en unos pocos archivos. Claude te da un punto de partida antes, y como estás dirigiendo cada paso, la deliberación adicional no habría cambiado mucho aparte de la espera.
372> Ejecute `/clear` entre tareas no relacionadas para restablecer el contexto.440* Reserva `max` para un problema difícil que quieres que Claude resuelva sin ti, como buscar una vulnerabilidad de seguridad. En tareas ordinarias tiende a pensar de más, así que pagas más por una respuesta que puede no ser mejor que la que te habría dado `high`.
441* Cuando solo el siguiente mensaje lo necesita, como una pregunta complicada en medio de un trabajo por lo demás rutinario, pon [`ultrathink`](https://code.claude.com/docs/es/model-config#use-ultrathink-for-one-off-deep-reasoning) en ese prompt en lugar de cambiar el ajuste.
373 442
374Claude Code compacta automáticamente el historial de conversación cuando se acerca a los límites de contexto, lo que preserva código importante y decisiones mientras libera espacio.443En cuanto al modelo en sí, Opus 5.5, el predeterminado, maneja bien la mayor parte de la programación, y Sonnet cuesta menos en el trabajo rutinario. [Claude Fable 5.1](https://code.claude.com/docs/es/model-config.md#work-with-fable) está disponible cuando lo seleccionas explícitamente con `/model fable`, y Haiku encaja bien para subagentes que hacen trabajos sencillos. [Configuración del modelo](https://code.claude.com/docs/es/model-config.md) tiene la lista completa por plan y proveedor.
375 444
376Durante sesiones largas, la ventana de contexto de Claude puede llenarse con conversación irrelevante, contenidos de archivo y comandos. Esto puede reducir el rendimiento y a veces distraer a Claude.445### Conoce lo que cuestan los subagentes
377 446
378* Use `/clear` frecuentemente entre tareas para restablecer completamente la ventana de contexto447Claude delega en [subagentes](https://code.claude.com/docs/es/sub-agents.md) por su cuenta:
379* Cuando se activa la compactación automática, Claude resume lo que más importa, incluyendo patrones de código, estados de archivo y decisiones clave
380* Para más control, ejecute `/compact <instructions>`, como `/compact Focus on the API changes`
381* Para compactar solo parte de la conversación, use `Esc + Esc` o `/rewind`, seleccione un punto de control de mensaje y elija **Summarize from here** o **Summarize up to here**. El primero condensa mensajes desde ese punto hacia adelante mientras mantiene el contexto anterior intacto; el segundo condensa mensajes anteriores mientras mantiene los recientes en su totalidad. Consulte [las opciones de resumición del menú de rebobinado](https://code.claude.com/docs/es/checkpointing.md#rewind-and-summarize).
382* Personalice el comportamiento de compactación en CLAUDE.md con instrucciones como `"When compacting, always preserve the full list of modified files and any test commands"` para asegurar que el contexto crítico sobreviva a la resumición
383* Para preguntas que no necesitan permanecer en contexto, use [`/btw`](https://code.claude.com/docs/es/interactive-mode#side-questions-with-%2Fbtw). La respuesta nunca entra en el historial de conversación, para que pueda verificar un detalle sin aumentar el contexto.
384 448
385### Use subagents para investigación449* Las búsquedas amplias en la base de código van al agente Explore integrado.
450* Las tareas secundarias se [bifurcan](https://code.claude.com/docs/es/sub-agents.md#fork-the-current-conversation) mientras el modo de bifurcación está activado (el valor predeterminado).
451* Los subagentes que inicia se ejecutan en segundo plano de forma predeterminada, así que tu conversación principal sigue avanzando.
386 452
387> [!TIP]453Rara vez necesitas pedir nada de esto, pero ayuda saber qué obtienes y cuánto cuesta.
388>
389> Delegue investigación con `"use subagents to investigate X"`. Exploran en un contexto separado, manteniendo su conversación principal limpia para la implementación.
390 454
391Dado que el contexto es su restricción fundamental, use subagents para mantener la investigación fuera de él. Cuando Claude investiga un código base, lee muchos archivos, todos los cuales consumen su contexto. Los subagents se ejecutan en ventanas de contexto separadas e informan resúmenes:455Los subagentes valen la pena en estas situaciones:
392 456
393```text wrap theme={null}457* Ejecutar trabajos independientes al mismo tiempo, para que toda la tarea termine antes
394Use subagents to investigate how our authentication system handles token458* Mantener la salida larga, como una ejecución completa de pruebas o una búsqueda amplia, fuera de tu conversación principal, donde de lo contrario viajaría contigo el resto de la sesión
395refresh, and whether we have any existing OAuth utilities I should reuse.459* Obtener un revisor que no ha visto cómo se escribió el código
396```460* Darle a una tarea menos herramientas de las que tiene la sesión principal, como un revisor que puede leer pero no editar
397 461
398También puede usar subagents para verificación después de que Claude implemente algo. Consulte [Agregue un paso de revisión adversarial](#add-an-adversarial-review-step).462Lo que te cuestan es sobre todo tokens, ya que cada subagente envía sus propias solicitudes y estas cuentan contra el mismo uso que tu conversación principal. A veces también cuestan tiempo: un subagente nuevo primero tiene que reunir el contexto que tu conversación ya tenía, así que puede terminar siendo *más lento* que hacer la tarea donde estás.
399 463
400### Rebobine con puntos de control464Y de forma predeterminada es el mismo modelo (o uno más pequeño) en la misma tarea. Obtienes paralelismo o una mirada nueva, pero no una respuesta más inteligente.
401 465
402> [!TIP]466Para gastar menos en ellos:
403>
404> Cada indicación que envía que inicia un turno crea un punto de control. Puede restaurar conversación, código o ambos a cualquier punto de control anterior.
405 467
406Claude automáticamente crea instantáneas de archivos antes de cada cambio para que un punto de control pueda restaurarlos. Presione Escape dos veces o ejecute `/rewind` para abrir el menú de rebobinado. Puede restaurar solo conversación, restaurar solo código, restaurar ambos o resumir desde un mensaje seleccionado. Consulte [Checkpointing](https://code.claude.com/docs/es/checkpointing.md) para detalles.468* Establece [`model: haiku`](https://code.claude.com/docs/es/sub-agents#choose-a-model) en la definición de un subagente si su trabajo es sencillo, como recopilar los archivos que importan un módulo o verificar los enlaces de la documentación. Ese tipo de trabajo no necesita el modelo más grande, y Haiku cuesta mucho menos por solicitud.
469* Pide resúmenes cortos de vuelta, para que veinte resultados no llenen tu contexto de todos modos.
470* Revisa `/usage` para ver qué proporción de tu uso consume cada tipo de subagente, y así saber cuáles justifican su costo.
471* Dale a un subagente personalizado en `.claude/agents/` solo `tools: Read, Grep, Glob`. Ahora es un revisor que no puede editar nada, y ese límite lo aplica Claude Code en lugar de solicitarse en un prompt.
407 472
408En lugar de planificar cuidadosamente cada movimiento, puede decirle a Claude que intente algo arriesgado. Si no funciona, rebobine e intente un enfoque diferente. Los puntos de control se guardan con la conversación, para que pueda cerrar su terminal, reanudar la sesión más tarde y aún rebobinar.473Ese revisor es un archivo corto, `.claude/agents/reviewer.md`:
409 474
410> [!WARNING]475```markdown .claude/agents/reviewer.md theme={null}
411>476---
412> Los puntos de control solo rastrean cambios realizados a través de las herramientas de edición de archivos de Claude. Los cambios realizados a través de comandos Bash o procesos externos no se capturan. Esto no es un reemplazo para git.477name: reviewer
478description: Reviews changed files against the spec they were built from. Use after implementing a feature, before opening the PR.
479tools: Read, Grep, Glob
480---
481You're reviewing code you didn't write. Compare the changed files against the spec you're given,
482check that every requirement is implemented and the listed edge cases have tests,
483and report only the gaps that affect correctness. Skip style.
484```
413 485
414### Reanudar conversaciones486Pídele a Claude `have the reviewer compare the rate limiter against SPEC.md` y las brechas vuelven a tu sesión, donde Claude puede corregirlas.
415 487
416> [!TIP]488### Reduce el costo y el contexto
417>
418> Nombre sesiones con `/rename` y trate las como ramas: cada flujo de trabajo obtiene su propio contexto persistente.
419 489
420Claude Code guarda conversaciones localmente, por lo que cuando una tarea abarca múltiples sesiones no tiene que re-explicar el contexto. Ejecute [`claude --continue`](https://code.claude.com/docs/es/sessions#resume-a-session) para continuar donde lo dejó, o `claude --resume` para elegir de una lista. Dé a las sesiones nombres descriptivos como `oauth-migration` para que pueda encontrarlas más tarde. Consulte [Gestione sesiones](https://code.claude.com/docs/es/sessions.md) para el conjunto completo de controles de reanudación, ramificación y denominación.490Con una ventana de 1M de tokens en la mayoría de los modelos actuales y la compactación cerca del tope, rara vez te quedarás sin contexto. Aun así, puedes *pagar* por contexto que no necesitas. Cada solicitud envía la conversación completa, así que una sesión que ha acumulado tres tareas no relacionadas vuelve a leer las tres en cada turno de la cuarta. Eso tiene [descuento mientras la caché está activa](https://code.claude.com/docs/es/costs.md#why-usage-climbs-in-a-long-session) y precio completo una vez que expira.
421 491
422***492[`/usage`](https://code.claude.com/docs/es/costs) es el primer lugar donde mirar. En Pro, Max, Team y Enterprise desglosa tu uso por skill, subagente, plugin y servidor MCP. También señala patrones como un contexto largo o fallos frecuentes de caché una vez que alguno supera el 10% de tu uso. A partir de ahí, las soluciones habituales:
423 493
424## Automatizar y escalar494* `/clear` entre tareas no relacionadas. No cuesta nada, y significa que la siguiente tarea no sigue pagando por el historial de la anterior. `/clear oauth-migration` le pone nombre a la sesión que dejas, para que puedas volver a ella más tarde.
495* `/compact` con un enfoque, como `/compact keep the API changes and the test commands`. En una sesión larga, `/compact` es en sí mismo una solicitud grande, ya que lee toda la conversación para resumirla, y más aún una vez que la caché ha expirado.
496* Vigila el trabajo en segundo plano: un `/loop`, la verificación de un objetivo después de cada turno y los propios subagentes de Claude siguen enviando solicitudes mientras no estás escribiendo.
425 497
426Una vez que seas efectivo con un Claude, multiplica tu salida con sesiones paralelas, modo no interactivo y patrones de distribución.498> [!NOTE]
499>
500> La [caché de prompts](https://code.claude.com/docs/es/prompt-caching.md) dura aproximadamente una hora con una suscripción y cinco minutos con una clave de API, un proveedor de nube o créditos de uso. Los subagentes obtienen cinco minutos a menos que lo cambies.
501>
502> Con la caché de una hora, una sesión de más de unos 200K tokens que queda inactiva se compacta poco antes de que la caché expire, así que después del almuerzo continúas desde un resumen. Si no necesitas el historial en absoluto, una sesión nueva sigue costando menos.
427 503
428### Ejecutar modo no interactivo504## Dirige la sesión
429 505
430> [!TIP]506> [!TIP]
431>507>
432> Usa `claude -p "prompt"` en CI, hooks de pre-commit o scripts. Agrega `--output-format stream-json --verbose` para salida JSON en streaming.508> Observa el primer minuto, presiona `Esc` en cuanto Claude se desvíe y, después de dos correcciones fallidas, ejecuta `/clear` y escribe un prompt mejor en lugar de una tercera.
433 509
434Con `claude -p "your prompt"`, puedes ejecutar Claude de forma no interactiva, sin un prompt interactivo. La ejecución aún crea una sesión reanudable a menos que pases `--no-session-persistence`. [El modo no interactivo](https://code.claude.com/docs/es/headless.md) es cómo integras Claude en canalizaciones de CI, hooks de pre-commit o cualquier flujo de trabajo automatizado. Los formatos de salida te permiten analizar resultados mediante programación: texto sin formato, JSON o JSON en streaming.510Ninguna configuración reemplaza observar el primer minuto e intervenir cuando Claude se dirige a donde no pretendías. Solo hay unos pocos controles para eso, y vale la pena conocerlos de memoria:
435 511
436```bash theme={null}512* `Esc` detiene a Claude a mitad de una acción y conserva todo hasta ese punto, para que puedas redirigirlo sin perder trabajo.
437# One-off queries513* `/rewind`, o `Esc` dos veces con el prompt vacío, abre el [menú de rebobinado](https://code.claude.com/docs/es/checkpointing.md#rewind-and-summarize), donde puedes devolver el código, la conversación o ambos a un prompt anterior. Eso hace que sea poco arriesgado probar primero el enfoque más audaz y rebobinar si no funciona. El mismo menú también puede resumir parte de la conversación cuando se ha quedado obsoleta.
438claude -p "Explain what this project does"514* `/clear` empieza de nuevo. Si has corregido lo mismo dos veces y sigue estando mal, una tercera corrección sobre todo agrega más a una conversación que ya contiene dos intentos fallidos que Claude sigue releyendo. `/clear` más un prompt nuevo que incorpore lo que aprendiste funciona mejor casi siempre.
439
440# Structured output for scripts
441claude -p "List all API endpoints" --output-format json
442 515
443# Streaming for real-time processing516> [!WARNING]
444claude -p "Analyze this log file" --output-format stream-json --verbose517>
445```518> Los checkpoints cubren los archivos que Claude editó con sus propias herramientas de archivos en tu conversación principal, así que un archivo que solo tocó un comando Bash [no se restaura](https://code.claude.com/docs/es/checkpointing.md#bash-command-changes-not-tracked). Funcionan junto con git, no lo reemplazan.
446 519
447El primer comando imprime texto sin formato. El formato `json` devuelve un único objeto JSON con un campo `result`. El formato `stream-json` imprime un objeto JSON por línea, comenzando con un evento de inicialización.520Dos más pequeños: [`/btw`](https://code.claude.com/docs/es/interactive-mode#side-questions-with-%2Fbtw) responde una pregunta rápida sin agregar nada al historial. Y para un trabajo que abarca varios días, `/rename oauth-migration` en la sesión le pone nombre, de modo que [`claude --resume oauth-migration`](https://code.claude.com/docs/es/sessions#resume-by-session-id-or-name) desde tu shell la retoma más tarde, checkpoints incluidos. `claude --continue` reanuda la más reciente.
448 521
449### Ejecutar múltiples sesiones de Claude522## Deja que Claude trabaje sin ti
450 523
451> [!TIP]524> [!TIP]
452>525>
453> Ejecuta múltiples sesiones de Claude en paralelo para acelerar el desarrollo, ejecutar experimentos aislados o iniciar flujos de trabajo complejos.526> Antes de dejar una ejecución desatendida, asegúrate de que sepa cómo se ve el trabajo terminado, pueda verificar su propio trabajo y solo pueda tocar lo que debe. Dale un límite de turnos o de gasto, y haz que una persona apruebe el resultado al final.
454
455Elige el enfoque paralelo que se ajuste a cuánta coordinación deseas hacer tú mismo, y agrega mensajería cuando las sesiones necesiten pasar hallazgos entre ellas:
456 527
457* [Worktrees](https://code.claude.com/docs/es/worktrees.md): ejecuta sesiones de CLI separadas en checkouts de git aislados para que las ediciones no choquen528Todo lo de esta página importa un poco más cuando no estás presente para detectar errores. Mientras observas, que a Claude le falte algo de contexto no es gran cosa: lo notas en uno o dos mensajes y se lo dices. En una ejecución que iniciaste antes de irte a dormir, nadie se lo dice, y a la mañana siguiente descubres que pasó toda la noche construyendo sobre una suposición equivocada.
458* [Mensajería entre sesiones](https://code.claude.com/docs/es/cross-session-messaging.md): permite que las sesiones que ejecutas tú mismo pasen hallazgos entre sí
459* [Aplicación de escritorio](https://code.claude.com/docs/es/desktop.md#work-in-parallel-with-sessions): administra múltiples sesiones locales visualmente, opcionalmente cada una en su propio worktree
460* [Usar Claude Code en la nube](https://code.claude.com/docs/es/claude-code-on-the-web.md): ejecuta sesiones en infraestructura administrada por Anthropic de forma predeterminada
461* [Vista de agente](https://code.claude.com/docs/es/agent-view.md): vista previa de investigación. Ejecuta `claude agents` para enviar sesiones que sigan ejecutándose en segundo plano y obsérvalas desde una pantalla
462* [Equipos de agentes](https://code.claude.com/docs/es/agent-teams.md): experimental y deshabilitado de forma predeterminada. Coordinación automatizada de múltiples sesiones con tareas compartidas, mensajería y un líder de equipo
463 529
464Más allá de paralelizar el trabajo, múltiples sesiones permiten flujos de trabajo enfocados en la calidad. Un contexto fresco mejora la revisión de código ya que Claude no estará sesgado hacia el código que acaba de escribir.530Antes de dejar una tarea ejecutándose por su cuenta, vale la pena repasar estas cinco preguntas pensando en esa tarea concreta:
465 531
466Por ejemplo, usa un patrón Escritor/Revisor:5321. ¿Sabe cómo se ve el trabajo terminado? Una condición de objetivo, un archivo de especificación o una prueba fallida que tiene que poner en verde.
5332. ¿Puede verificar su propio trabajo? El conjunto de pruebas, un hook `Stop`, algún tipo de paso de revisión.
5343. ¿Qué puede tocar? Reglas de permisos, `dontAsk`, el sandbox, un worktree, la única rama a la que puede hacer push.
5354. ¿Qué lo detiene? `--max-turns`, `--max-budget-usd`, un límite de gasto.
5365. ¿Adónde va el resultado y quién da el visto bueno? Un PR, un comentario o un resumen, y luego una persona que aprueba la fusión, el despliegue o cualquier otra cosa que no se pueda deshacer.
467 537
468| Sesión A (Escritor) | Sesión B (Revisor) |538Una vez en marcha, Claude llevará adelante una tarea larga por su cuenta. Las partes que quedan en tus manos son iniciarla, decidir qué significa "terminado" esta vez y aprobar la fusión al final.
469| - | - |
470| `Implement a rate limiter for our API endpoints` | |
471| | `Review the rate limiter implementation in @src/middleware/rateLimiter.ts. Look for edge cases, race conditions, and consistency with our existing middleware patterns.` |
472| `Here's the review feedback: [Session B output]. Address these issues.` | |
473 539
474Puedes hacer algo similar con pruebas: haz que un Claude escriba pruebas, luego otro escriba código para pasarlas.540### Ejecuta Claude desde un script
475 541
476### Distribuir entre archivos542[`claude -p "prompt"`](https://code.claude.com/docs/es/headless) se ejecuta una vez y termina, y así es como Claude Code acaba en trabajos de CI, hooks de git y bucles de shell.
477
478> [!TIP]
479>
480> Recorre tareas llamando a `claude -p` para cada una. Usa `--allowedTools` para aprobar previamente herramientas para operaciones por lotes.
481 543
482Para migraciones o análisis grandes, puedes distribuir el trabajo entre muchas invocaciones paralelas de Claude. Ejecuta [`/batch <instruction>`](https://code.claude.com/docs/es/commands#all-commands) para que Claude divida el cambio entre 5 a 30 subagentes. Cada subagente trabaja en su propio worktree. Para impulsar la distribución desde tu propio script en su lugar, recorre `claude -p`:544En un script casi siempre querrás algunos flags más:
483 545
484**1. Generar una lista de tareas**546* [`--bare`](https://code.claude.com/docs/es/headless#start-faster-with-bare-mode) omite hooks, skills, plugins, servidores MCP y archivos `CLAUDE.md`, tanto los del repositorio como los de la máquina, para que la ejecución haga lo mismo dondequiera que se ejecute. Tampoco toca nunca tu inicio de sesión de claude.ai: la autenticación proviene de `ANTHROPIC_API_KEY`, de un `apiKeyHelper` en el archivo que pasas con `--settings` o de las credenciales de tu proveedor de nube.
547* `--append-system-prompt`, `--mcp-config` y `--settings` pasan explícitamente lo que la ejecución *sí* necesita.
548* `--allowedTools` aprueba previamente sus herramientas, y [`--permission-mode dontAsk`](https://code.claude.com/docs/es/permission-modes#allow-only-pre-approved-tools-with-dontask-mode) rechaza cualquier otra cosa que habría pedido aprobación.
549* `--output-format json` te da un único objeto de resultado para analizar, y `stream-json` con `--verbose` transmite los eventos a medida que ocurren.
485 550
486Haz que Claude escriba la lista de archivos que necesitan migración en un archivo, para que el bucle en el siguiente paso pueda leerlo, con un prompt como `list all 2,000 Python files that need migrating and save the list to files.txt`551Todo junto, se ve así:
487
488**2. Escribir un script para recorrer la lista**
489 552
490```bash theme={null}553```bash theme={null}
491for file in $(cat files.txt); do554for file in $(cat files.txt); do
492 claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \555 claude --bare -p "Migrate $file to the new logger API and commit. Reply OK or FAIL." \
493 --allowedTools "Edit,Bash(git commit *)" \556 --allowedTools "Read,Edit,Bash(git add *),Bash(git commit *)" \
494 --permission-mode dontAsk557 --permission-mode dontAsk \
558 --max-turns 20
495done559done
496```560```
497 561
498**3. Probar en algunos archivos, luego ejecutar en todos ellos**562Cuando una ejecución termina, Claude responde `OK` o `FAIL`, y una ejecución que alcanza el límite de turnos sale con un error en su lugar. Pruébalo primero con tres archivos, observa qué sale mal, corrige el prompt y luego ejecuta el resto.
499
500Refina tu prompt basándote en lo que sale mal con los primeros 2-3 archivos, luego ejecuta en el conjunto completo. El flag `--allowedTools` aprueba previamente las herramientas que necesita la migración. [`--permission-mode dontAsk`](https://code.claude.com/docs/es/permission-modes#allow-only-pre-approved-tools-with-dontask-mode) deniega cualquier otra cosa que requeriría aprobación, lo que importa cuando estás ejecutando sin supervisión, aunque un [mod](https://code.claude.com/docs/es/plugins/mods/overview.md) que hayas instalado todavía puede aprobar algunas de esas llamadas.
501 563
502También puedes integrar Claude en canalizaciones de datos/procesamiento existentes:564El modo automático también funciona con `-p` si pasas `--permission-mode auto`. En una ejecución no interactiva, un bloqueo del clasificador deniega esa acción concreta y Claude continúa, y los bloqueos repetidos no pausan la ejecución como lo hacen en una terminal. Lee [cómo se aplican allí los umbrales](https://code.claude.com/docs/es/permission-modes.md#repeated-block-thresholds) antes de confiar en ello.
503 565
504```bash theme={null}566### Inicia ejecuciones según un horario o un evento
505claude -p "<your prompt>" --output-format json | your_command
506```
507 567
508### Ejecutar de forma autónoma con modo automático568Una vez que una ejecución está en marcha, Claude puede encargarse del resto por sí mismo. Lo único que no puede hacer es decidir *empezar*, así que algo tiene que hacerlo: tú, un temporizador o un evento como una verificación de CI fallida o un nuevo PR.
509 569
510Para ejecución ininterrumpida con comprobaciones de seguridad en segundo plano, usa el [modo automático](https://code.claude.com/docs/es/permission-modes.md#eliminate-prompts-with-auto-mode). Un modelo clasificador revisa los comandos antes de que se ejecuten, bloqueando escalada de alcance, infraestructura desconocida y acciones impulsadas por contenido hostil mientras permite que el trabajo habitual continúe sin solicitudes de permiso.570Dentro de una sesión abierta, eso es [`/loop`](https://code.claude.com/docs/es/scheduled-tasks#run-a-prompt-repeatedly-with-%2Floop), que repite un prompt en un intervalo:
511 571
512```bash theme={null}572```text theme={null}
513claude --permission-mode auto -p "fix all lint errors"573/loop 15m check CI on this branch, and if it's red pull the failing job's log, fix it and push
514```574```
515 575
516Cuando el clasificador bloquea repetidamente acciones en una ejecución no interactiva con el flag `-p`, Claude Code no detiene la ejecución. Consulta [cuándo el modo automático retrocede](https://code.claude.com/docs/es/permission-modes.md#when-auto-mode-falls-back) para saber qué sucede en su lugar y para los umbrales.576Cada ejecución es otro turno en la misma sesión, así que no dejes uno en marcha en una conversación larga. Para cualquier cosa que deba ocurrir mientras tu portátil está cerrada, [`/schedule`](https://code.claude.com/docs/es/routines#create-from-the-cli) configura una [tarea programada en la nube](https://code.claude.com/docs/es/routines.md) que se ejecuta con un temporizador. Necesita un inicio de sesión de claude.ai en lugar de una clave de API. Puedes agregar un disparador de eventos de GitHub pidiéndoselo a Claude, o un disparador de API en [claude.ai/code/routines](https://claude.ai/code/routines).
517
518### Agregar un paso de revisión adversarial
519 577
520> [!TIP]578> [!WARNING]
521>579>
522> Antes de tratar una tarea como completada, haz que un subagente revise el diff en un contexto fresco e informe sobre brechas.580> Antes de dejar una tarea programada en la nube en ejecución, protege `main` con una [regla de rama de GitHub que la tarea no pueda eludir](https://code.claude.com/docs/es/routines.md#repositories-and-branch-permissions). Y observa las primeras ejecuciones de cualquier cosa nueva antes de confiar en ella sin supervisión.
523
524Cuanto más tiempo trabaje Claude sin supervisión, más importa una verificación independiente antes de contar el trabajo como completado. Un revisor que se ejecuta en un contexto de [subagente](https://code.claude.com/docs/es/sub-agents.md) fresco ve solo el diff y los criterios que le proporcionas, no el razonamiento que produjo el cambio, por lo que evalúa el resultado en sus propios términos.
525 581
526Para una verificación de corrección, ejecuta el [skill `/code-review`](https://code.claude.com/docs/es/commands) incluido, que revisa el diff actual en busca de errores en un subagente fresco y devuelve hallazgos a la sesión. Para verificar el diff contra tu plan en su lugar, escribe el prompt de revisión tú mismo. Nombra el trabajo a verificar, el plan contra el cual verificarlo y qué cuenta como un hallazgo:582### Ejecuta sesiones en paralelo
527 583
528```text wrap theme={null}584Cuando tienes varios trabajos separados en marcha a la vez, dale a cada uno su propio checkout para que las ediciones no choquen. [`claude -w feature-auth`](https://code.claude.com/docs/es/worktrees#start-claude-in-a-worktree) inicia una sesión en un nuevo worktree, la [aplicación de escritorio](https://code.claude.com/docs/es/desktop.md#work-in-parallel-with-sessions) ejecuta varias de estas una al lado de otra, y las [sesiones en la nube](https://code.claude.com/docs/es/claude-code-on-the-web.md) las ejecutan en la nube en lugar de en tu máquina.
529Use a subagent to review the rate limiter diff against PLAN.md. Check that
530every requirement is implemented, the listed edge cases have tests, and
531nothing outside the task's scope changed. Report gaps, not style preferences.
532```
533 585
534Debido a que el revisor se ejecuta como un subagente, la sesión de implementación recibe las brechas directamente y puede corregirlas y revisar nuevamente sin que tú copies hallazgos entre ventanas.586Un worktree es un checkout nuevo, lo que significa que los archivos ignorados por git como `.env` no están ahí y las dependencias no están instaladas. Para lo primero, enumera los archivos ignorados por git que necesitas en un [`.worktreeinclude`](https://code.claude.com/docs/es/worktrees#copy-gitignored-files-into-worktrees) en la raíz del repositorio (misma sintaxis que `.gitignore`) y Claude Code los copia en cada worktree que crea:
535 587
536Un revisor al que se le pide encontrar brechas generalmente reportará algunas, incluso cuando el trabajo es sólido, porque eso es lo que se le pidió que hiciera. Perseguir cada hallazgo conduce a sobreingeniería: capas de abstracción adicionales, código defensivo y pruebas para casos que no pueden suceder. Dile al revisor que marque solo brechas que afecten la corrección o los requisitos establecidos, y trata el resto como opcional.588```text .worktreeinclude theme={null}
589.env
590.env.local
591config/dev-credentials.json
592```
537 593
538***594Limítalo a archivos pequeños: copia en lugar de enlazar, así que tener `node_modules` ahí significaría una copia completa por worktree. Para directorios grandes existe el ajuste [`worktree.symlinkDirectories`](https://code.claude.com/docs/es/settings-reference#worktree-symlinkdirectories), o bien mantén el comando de instalación en `CLAUDE.md` para que Claude lo ejecute cada vez que empiece en un checkout nuevo.
539 595
540## Evite patrones de falla comunes596Rara vez tienes que limpiar nada de esto tú mismo:
541 597
542Estos son errores comunes. Reconocerlos temprano ahorra tiempo:598* Cuando sales de una sesión de worktree sin nombre, Claude Code [elimina el worktree](https://code.claude.com/docs/es/worktrees.md#clean-up-worktrees) si no hay nada en él. Para una sesión con nombre, o una con cambios, te pregunta qué hacer.
599* Los worktrees de subagentes desaparecen cuando el subagente termina sin cambios.
600* Los worktrees de subagentes y de sesiones en segundo plano que sí quedan se eliminan una vez que superan `cleanupPeriodDays` y no contienen trabajo.
543 601
544* **La sesión de todo incluido.** Comienza con una tarea, luego pregunta a Claude algo no relacionado, luego vuelve a la primera tarea. El contexto está lleno de información irrelevante.602> [!NOTE]
545 > **Solución**: `/clear` entre tareas no relacionadas.603>
546* **Corrección una y otra vez.** Claude hace algo mal, lo corrige, sigue siendo incorrecto, lo corrige de nuevo. El contexto está contaminado con enfoques fallidos.604> Una ejecución `claude -p --worktree` es una que limpias tú mismo, ya que termina sin preguntar. Elimínalas con `git worktree remove <path>` y, si git se niega porque el worktree está bloqueado, primero ejecuta `git worktree unlock <path>`.
547 > **Solución**: Después de dos correcciones fallidas, `/clear` y escriba una indicación inicial mejor incorporando lo que aprendió.
548* **El CLAUDE.md sobre especificado.** Si su CLAUDE.md es demasiado largo, Claude ignora la mitad porque las reglas importantes se pierden en el ruido.
549 > **Solución**: Elimine sin piedad. Si Claude ya hace algo correctamente sin la instrucción, elimínelo o conviértalo en un hook.
550* **La brecha de confianza-luego-verificación.** Claude produce una implementación que se ve plausible pero no maneja casos extremos.
551 > **Solución**: Siempre proporcione verificación (pruebas, scripts, capturas de pantalla). Si no puede verificarlo, no lo envíe.
552* **La exploración infinita.** Pide a Claude que "investigue" algo sin delimitarlo. Claude lee cientos de archivos, llenando el contexto.
553 > **Solución**: Delimite investigaciones estrechamente o use subagents para que la exploración no consuma su contexto principal.
554 605
555***606Para un gran cambio mecánico en muchos archivos, [`/batch migrate every handler to the v2 response helpers`](https://code.claude.com/docs/es/commands) divide el trabajo en entre 5 y 30 unidades y te muestra el plan. Luego ejecuta cada unidad en su propio worktree y abre un PR para ella. Desde tu shell, [`claude agents`](https://code.claude.com/docs/es/agent-view) (todavía en vista previa de investigación) te da una sola pantalla para todo lo que se ejecuta en segundo plano en tu máquina.
556 607
557## Desarrolle su intuición608Una segunda sesión es también el revisor independiente más fácil que puedes conseguir. Una sesión escribe el limitador de velocidad, otra revisa `@src/middleware/rateLimiter.ts` sin haber visto cómo se escribía, y tú pegas los hallazgos de vuelta en la primera. Es la misma idea que `/code-review`, pero eres tú quien lleva los mensajes.
558 609
559Los patrones en esta guía no están grabados en piedra. Son puntos de partida que funcionan bien en general, pero podrían no ser óptimos para cada situación.610## Lo que puedes dejar de hacer
560 611
561A veces *debería* dejar que el contexto se acumule porque está profundo en un problema complejo y el historial es valioso. A veces debería omitir la planificación y dejar que Claude lo descubra porque la tarea es exploratoria. A veces una indicación vaga es exactamente lo correcto porque desea ver cómo Claude interpreta el problema antes de limitarlo.612Cada uno de estos fue un buen consejo cuando se escribió. La mayoría eran soluciones alternativas para algo que el modelo todavía no podía hacer de forma fiable, y desde entonces los modelos se han puesto al día. Si algunos siguen siendo hábitos, aquí está por qué es seguro abandonarlos.
562 613
563Preste atención a lo que funciona. Cuando Claude produce una salida excelente, note lo que hizo: la estructura de la indicación, el contexto que proporcionó, el modo en que estaba. Cuando Claude lucha, pregúntese por qué. ¿Fue el contexto demasiado ruidoso? ¿La indicación demasiado vaga? ¿La tarea demasiado grande para un pase?614| El consejo antiguo | Por qué ya no aplica |
615| :- | :- |
616| La ventana de contexto es tu principal restricción, gestiónala agresivamente | La mayoría de los modelos actuales tienen una ventana de 1M de tokens y la compactación ocurre por sí sola, así que quedarse sin contexto es poco común. `/clear` entre tareas sigue valiendo la pena, porque un contexto enfocado te da mejores respuestas y cuesta menos. |
617| Agrega IMPORTANT o MAYÚSCULAS a las instrucciones que Claude sigue pasando por alto | Los modelos anteriores a veces necesitaban el énfasis. Los actuales siguen una línea redactada con sencillez, y acumular énfasis sobre todo hace que Claude aplique la regla en exceso. Si es una regla que no puede flexibilizarse, conviértela en un hook o una regla de denegación. Si la línea se pierde en un archivo largo, el archivo necesita ser más corto. |
618| Usa subagentes para proteger tu ventana de contexto | Quedarse sin contexto ya rara vez es el problema. Los subagentes siguen siendo excelentes para el trabajo en paralelo, para mantener fuera de tu camino la salida ruidosa y para la revisión independiente, pero cada uno de esos usos cuesta tokens adicionales. |
619| Delega en un subagente para obtener una mejor respuesta | Pasarle la misma tarea a un subagente no mejora la respuesta. Un revisor nuevo sí ayuda, porque no ha visto tu razonamiento, lo cual es algo distinto de delegar. |
620| `think hard`, `think harder`, `be thorough` en el prompt | El esfuerzo es el control para eso. Esas frases son texto de prompt normal que empuja a Claude dentro de su ajuste de esfuerzo, no palabras clave que lo eleven. `ultrathink` sigue funcionando: pide un razonamiento más profundo en ese único turno sin tocar tu ajuste de esfuerzo. |
621| Dile a Claude que siga adelante, que itere hasta terminar, que no sea perezoso | Los modelos actuales normalmente continúan con una tarea acordada sin que se lo digan, y ese tipo de líneas tienen más probabilidades de provocar trabajo de más que de resolver un estancamiento. Darle a Claude una verificación que superar es distinto, y sigue valiendo la pena. Si una ejecución se detiene antes de tiempo, di `continue`, y para las ejecuciones que nadie está observando, `/goal` o un hook `Stop` lo exigen. |
622| Describe tu arquitectura y la estructura de archivos en `CLAUDE.md` | Claude lee el repositorio por sí mismo. Escribe solo lo que no está ahí. |
564 623
565Con el tiempo, desarrollará intuición que ninguna guía puede capturar. Sabrá cuándo ser específico y cuándo ser abierto, cuándo planificar y cuándo explorar, cuándo limpiar contexto y cuándo dejarlo acumular.624Si algún otro consejo de esta página empieza a parecerte trabajo innecesario, probablemente sea señal de que también pertenece a esta tabla.
566 625
567## Recursos relacionados626## Recursos relacionados
568 627
569* [Cómo funciona Claude Code](https://code.claude.com/docs/es/how-claude-code-works.md): el bucle agencial, herramientas y gestión de contexto628* [Cómo funciona Claude Code](https://code.claude.com/docs/es/how-claude-code-works.md): el bucle, las herramientas y lo que se carga al inicio
570* [Extender Claude Code](https://code.claude.com/docs/es/features-overview.md): skills, hooks, MCP, subagents y plugins629* [Explora la ventana de contexto](https://code.claude.com/docs/es/context-window.md): qué ocupa espacio en una sesión y cuándo se carga
571* [Flujos de trabajo comunes](https://code.claude.com/docs/es/common-workflows.md): recetas paso a paso para depuración, pruebas, PRs y más630* [Extiende Claude Code](https://code.claude.com/docs/es/features-overview.md): cómo elegir entre skills, hooks, MCP, subagentes y plugins
572* [CLAUDE.md](https://code.claude.com/docs/es/memory.md): almacenar convenciones de proyecto y contexto persistente631* [Elige un modo de permisos](https://code.claude.com/docs/es/permission-modes.md) y [Configura los permisos](https://code.claude.com/docs/es/permissions.md)
632* [Gestiona los costos de forma eficaz](https://code.claude.com/docs/es/costs.md)
633* [Ejecuta Claude Code mediante programación](https://code.claude.com/docs/es/headless.md) y [Automatiza el trabajo con tareas programadas en la nube](https://code.claude.com/docs/es/routines.md)
634* Para líderes de equipo y administradores: [Configura Claude Code para tu organización](https://code.claude.com/docs/es/admin-setup.md)
