Mejores prácticas para Claude Code

Consejos y patrones para aprovechar al máximo Claude Code, desde configurar su entorno hasta escalar entre sesiones paralelas.

Claude 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.

Esto 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.

Pero esta autonomía aún viene con una curva de aprendizaje. Claude trabaja dentro de ciertas restricciones que necesita entender.

Esta 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.

La 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.

La 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.

Esto 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 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, y consulte Reducir el uso de tokens para estrategias sobre cómo reducir el uso de tokens.

Dé a Claude una forma de verificar su trabajo

Claude 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.

La 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 comparada con un diseño. Ejecute /verify usted mismo después de que la verificación de Claude pase para confirmar el cambio contra la aplicación en ejecución.

Una vez que la verificación existe, decida qué tan estrictamente detiene el trabajo:

• En un solo mensaje: pida a Claude que ejecute la verificación e itere en el mismo mensaje, como en la tabla anterior.
• En toda una sesión: establezca la verificación como una condición /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.
• Como una puerta determinista: un hook Stop ejecuta su verificación como un script y bloquea el final del turno hasta que pase. Claude Code anula el hook y finaliza el turno después de 8 bloqueos consecutivos.
• Por una segunda opinión: un subagente de verificación o un flujo de trabajo dinámico 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.

Cada 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.

Haga 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.

Explore primero, luego planifique, luego codifique

Dejar que Claude salte directamente a la codificación puede producir código que resuelve el problema incorrecto. Use plan mode para separar la exploración de la ejecución.

El flujo de trabajo recomendado tiene cuatro fases:

read /src/auth and understand how we handle sessions and login.
also look at how we manage environment variables for secrets.

I want to add Google OAuth. What files need to change?
What's the session flow? Create a plan.

implement the OAuth flow from your plan. write tests for the
callback handler, run the test suite and fix any failures.

commit with a descriptive message and open a PR

Proporcione contexto específico en sus indicaciones

Claude puede inferir intención, pero no puede leer su mente. Haga referencia a archivos específicos, mencione restricciones y señale patrones de ejemplo.

Las 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.

Proporcionar contenido enriquecido

Puede proporcionar datos enriquecidos a Claude de varias maneras:

• Haga referencia a archivos con @ en lugar de describir dónde vive el código. Claude lee el archivo antes de responder.
• Pegue imágenes directamente. Copie/pegue o arrastre y suelte imágenes en la indicación.
• Proporcione URLs para documentación y referencias de API. Use /permissions para permitir dominios de uso frecuente.
• Canalice datos ejecutando cat error.log | claude para enviar contenidos de archivo directamente.
• Deje que Claude obtenga lo que necesita. Diga a Claude que extraiga contexto por sí mismo usando comandos Bash, herramientas MCP o leyendo archivos.

Configura tu entorno

Algunos 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.

Escribe un CLAUDE.md efectivo

CLAUDE.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.

No hay un formato requerido para los archivos CLAUDE.md, pero mantenlos cortos y legibles para humanos. Por ejemplo:

# Code style
- Use ES modules (import/export) syntax, not CommonJS (require)
- Destructure imports when possible (eg. import { foo } from 'bar')

# Workflow
- Be sure to typecheck when you're done making a series of code changes
- Prefer running single tests, and not the whole test suite, for performance

Ejecuta /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 en su lugar. Claude los carga bajo demanda sin saturar cada conversación.

Mantenlo 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.

Si 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 y Claude propone cortes para contenido que puede derivar de la base de código.

Si 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.

Los 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.

Configura permisos

En los planes Pro, Max y Team, el modo automático es el modo de permiso inicial integrado 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 modo Manual, el modo de permiso inicial integrado en otros planes, 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:

• Listas de permisos: permiten herramientas específicas que sabes que son seguras, como npm run lint o git commit
• 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

Lee más sobre permission modes, permission rules y sandboxing.

Usa herramientas CLI

Las 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.

Claude 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.

Conecta servidores MCP

Con MCP servers, 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.

Configura hooks

Hooks 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.

Claude 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.

Crea skills

Skills 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.

Crea una skill añadiendo un directorio con un SKILL.md a .claude/skills/:

---
name: api-conventions
description: REST API design conventions for our services
---
# API Conventions
- Use kebab-case for URL paths
- Use camelCase for JSON properties
- Always include pagination for list endpoints
- Version APIs in the URL path (/v1/, /v2/)

Las skills también pueden definir flujos de trabajo repetibles que invocas directamente:

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---
Analyze and fix the GitHub issue: $ARGUMENTS.

1. Use `gh issue view` to get the issue details
2. Understand the problem described in the issue
3. Search the codebase for relevant files
4. Implement the necessary changes to fix the issue
5. Write and run tests to verify the fix
6. Ensure code passes linting and type checking
7. Create a descriptive commit message
8. Push and create a PR

Ejecuta /fix-issue 1234 para invocarlo. Usa disable-model-invocation: true para flujos de trabajo con efectos secundarios que quieres activar manualmente.

Crea subagentes personalizados

Subagents 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.

---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior security engineer. Review code for:
- Injection vulnerabilities (SQL, XSS, command injection)
- Authentication and authorization flaws
- Secrets or credentials in code
- Insecure data handling

Provide specific line references and suggested fixes.

Dile a Claude que use subagentes explícitamente: "Use a subagent to review this code for security issues."

Instala plugins

Plugins 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 para darle a Claude navegación de símbolos precisa y detección automática de errores después de ediciones.

Para orientación sobre cómo elegir entre skills, subagentes, hooks y MCP, consulta Extend Claude Code.

Comuníquese efectivamente

Haga 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.

Haga preguntas sobre el código base

Al 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:

• ¿Cómo funciona el registro?
• ¿Cómo hago un nuevo punto final de API?
• ¿Qué hace async move { ... } en la línea 134 de foo.rs?
• ¿Qué casos extremos maneja CustomerOnboardingFlowImpl?
• ¿Por qué este código llama a foo() en lugar de bar() en la línea 333?

Usar 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.

Deje que Claude lo entreviste

Claude 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.

I want to build [brief description]. Interview me in detail using the AskUserQuestion tool.

Ask 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.

Keep interviewing until we've covered everything, then write a complete spec to SPEC.md.

Una 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.

Las 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.

Gestione su sesión

Las conversaciones son persistentes y reversibles. ¡Úselo a su favor!

Corrija el curso temprano y a menudo

Los 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.

• Esc: detener a Claude a mitad de acción con la tecla Esc. El contexto se preserva, para que pueda redirigir.
• 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.
• "Undo that": haga que Claude revierta sus cambios.
• /clear: restablecer contexto entre tareas no relacionadas. Las sesiones largas con contexto irrelevante pueden reducir el rendimiento.

Si 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.

Gestione el contexto agresivamente

Claude 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.

Durante 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.

• Use /clear frecuentemente entre tareas para restablecer completamente la ventana de contexto
• 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
• Para más control, ejecute /compact <instructions>, como /compact Focus on the API changes
• 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.
• 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
• Para preguntas que no necesitan permanecer en contexto, use /btw. La respuesta nunca entra en el historial de conversación, para que pueda verificar un detalle sin aumentar el contexto.

Use subagents para investigación

Dado 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:

Use subagents to investigate how our authentication system handles token
refresh, and whether we have any existing OAuth utilities I should reuse.

También puede usar subagents para verificación después de que Claude implemente algo. Consulte Agregue un paso de revisión adversarial.

Rebobine con puntos de control

Claude 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 para detalles.

En 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.

Reanudar conversaciones

Claude Code guarda conversaciones localmente, por lo que cuando una tarea abarca múltiples sesiones no tiene que re-explicar el contexto. Ejecute claude --continue 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 para el conjunto completo de controles de reanudación, ramificación y denominación.

Automatizar y escalar

Una vez que sea efectivo con un Claude, multiplique su salida con sesiones paralelas, modo no interactivo y patrones de distribución.

Ejecutar modo no interactivo

Con claude -p "su prompt", puede ejecutar Claude de forma no interactiva, sin un prompt interactivo. La ejecución aún crea una sesión reanudable a menos que pase --no-session-persistence. El modo no interactivo es cómo integra Claude en canalizaciones de CI, hooks de pre-commit o cualquier flujo de trabajo automatizado. Los formatos de salida le permiten analizar resultados mediante programación: texto sin formato, JSON o JSON en streaming.

# Consultas puntuales
claude -p "Explain what this project does"

# Salida estructurada para scripts
claude -p "List all API endpoints" --output-format json

# Streaming para procesamiento en tiempo real
claude -p "Analyze this log file" --output-format stream-json --verbose

El 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.

Ejecutar múltiples sesiones de Claude

Elija el enfoque paralelo que se ajuste a cuánta coordinación desea hacer usted mismo, y agregue mensajería cuando las sesiones necesiten pasar hallazgos entre ellas:

• Git Worktrees: ejecute sesiones de CLI separadas en checkouts de git aislados para que las ediciones no choquen
• Mensajería entre sesiones: permita que las sesiones que ejecuta usted mismo pasen hallazgos entre sí
• Aplicación de escritorio: administre múltiples sesiones locales visualmente, opcionalmente cada una en su propio worktree
• Claude Code en la web: ejecute sesiones en la nube, en infraestructura administrada por Anthropic de forma predeterminada
• Vista de agente: vista previa de investigación. Ejecute claude agents para enviar sesiones que sigan ejecutándose en segundo plano y obsérvelas desde una pantalla
• Equipos de agentes: experimental y deshabilitado de forma predeterminada. Coordinación automatizada de múltiples sesiones con tareas compartidas, mensajería y un líder de equipo

Má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.

Por ejemplo, use un patrón Escritor/Revisor:

Puede hacer algo similar con pruebas: haga que un Claude escriba pruebas, luego otro escriba código para pasarlas.

Distribuir entre archivos

Para migraciones o análisis grandes, puede distribuir el trabajo entre muchas invocaciones paralelas de Claude. Ejecute /batch <instruction> para que Claude divida el cambio entre 5 a 30 subagentes. Cada subagente trabaja en su propio worktree. Para impulsar la distribución desde su propio script en su lugar, recorra claude -p:

for file in $(cat files.txt); do
claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \
--allowedTools "Edit,Bash(git commit *)"
done

También puede integrar Claude en canalizaciones de datos/procesamiento existentes:

claude -p "<your prompt>" --output-format json | your_command

Ejecutar de forma autónoma con modo automático

Para ejecución ininterrumpida con comprobaciones de seguridad en segundo plano, use modo automático. 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 rutinario continúe sin prompts.

claude --permission-mode auto -p "fix all lint errors"

Cuando el clasificador bloquea repetidamente acciones en una ejecución no interactiva con la bandera -p, Claude Code no detiene la ejecución. Vea cuándo el modo automático retrocede para saber qué sucede en su lugar y para los umbrales.

Agregar un paso de revisión adversarial

Cuanto 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 fresco ve solo el diff y los criterios que le proporciona, no el razonamiento que produjo el cambio, por lo que evalúa el resultado en sus propios términos.

Para una verificación de corrección, ejecute la skill /code-review incluida, 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 su plan en su lugar, escriba el prompt de revisión usted mismo. Nombre el trabajo a verificar, el plan a verificar contra él y qué cuenta como un hallazgo:

Use a subagent to review the rate limiter diff against PLAN.md. Check that
every requirement is implemented, the listed edge cases have tests, and
nothing outside the task's scope changed. Report gaps, not style preferences.

Debido 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 usted copie hallazgos entre ventanas.

Evite patrones de falla comunes

Estos son errores comunes. Reconocerlos temprano ahorra tiempo:

• 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.

  Solución: /clear entre tareas no relacionadas.

• 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.

  Solución: Después de dos correcciones fallidas, /clear y escriba una indicación inicial mejor incorporando lo que aprendió.

• 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.

  Solución: Elimine sin piedad. Si Claude ya hace algo correctamente sin la instrucción, elimínelo o conviértalo en un hook.

• La brecha de confianza-luego-verificación. Claude produce una implementación que se ve plausible pero no maneja casos extremos.

  Solución: Siempre proporcione verificación (pruebas, scripts, capturas de pantalla). Si no puede verificarlo, no lo envíe.

• La exploración infinita. Pide a Claude que "investigue" algo sin delimitarlo. Claude lee cientos de archivos, llenando el contexto.

  Solución: Delimite investigaciones estrechamente o use subagents para que la exploración no consuma su contexto principal.

Desarrolle su intuición

Los 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.

A 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.

Preste 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?

Con 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.

Recursos relacionados

• Cómo funciona Claude Code: el bucle agencial, herramientas y gestión de contexto
• Extender Claude Code: skills, hooks, MCP, subagents y plugins
• Flujos de trabajo comunes: recetas paso a paso para depuración, pruebas, PRs y más
• CLAUDE.md: almacenar convenciones de proyecto y contexto persistente