La mayoría de la gente abre Claude Code, escribe un prompt, espera la respuesta, escribe otro prompt.
Eso es como comprar un Ferrari y solo conducirlo en primera marcha.
Quería entender por qué algunas personas parecen sacarle 10 veces más partido a Claude Code que otras. Así que hice lo que cualquier persona razonable haría: me leí todo el código fuente (cuando digo "yo", me refiero a Claude Code, obviamente).
11 capas de arquitectura. Miles de líneas. Una plataforma de orquestación de agentes disfrazada de chat de terminal.
Esto es lo que revela el código fuente sobre cómo usar esto de verdad.
1. CLAUDE.md se carga en cada turno. Cada. Maldito. Turno.
Esto es lo que tiene mayor apalancamiento que puedes hacer y casi nadie lo hace bien.
La mayoría o no tiene nada en su archivo CLAUDE.md, o se han escrito la biblia entera.
El código fuente muestra que Claude Code lee tus archivos CLAUDE.md en CADA iteración de consulta. No al inicio de la sesión. Cada turno. Eso significa que cada vez que envías un mensaje, vuelve a leer tus instrucciones.
Hay toda una jerarquía:
~/.claude/CLAUDE.md— global (tu estilo de codificación, preferencias)
./CLAUDE.md— a nivel de proyecto (decisiones de arquitectura, convenciones)
.claude/rules/*.md— reglas modulares
CLAUDE.local.md— notas privadas (ignoradas por git)
Tienes 40.000 caracteres. Eso es MUCHO. La mayoría usa quizás 200.
Pon ahí tus decisiones de arquitectura. Tus convenciones de archivos. Tus patrones de testing. Tus reglas de "nunca hagas esto". El modelo las lee en cada turno. Esta es la diferencia entre que Claude Code sea un asistente genérico y que sea TU asistente que conoce TU base de código.
Si haces una sola cosa después de leer esto, que sea esta.
2. Los subagentes comparten la caché de prompts (el paralelismo es prácticamente gratis)
Esto es lo que me voló la cabeza.
Cuando Claude Code bifurca un subagente, crea una copia idéntica byte por byte del contexto padre. La API almacena esto en caché. Así que lanzar 5 agentes para trabajar en diferentes partes de tu base de código cuesta apenas más que 1 agente haciéndolo secuencialmente.
Léelo de nuevo.
5 agentes. Mismo coste que 1. Porque todos usan la misma caché de prompts.
La mayoría usa Claude Code como un trabajador único. Una tarea a la vez. Esperar a que termine. Darle la siguiente.
El código fuente tiene literalmente tres modelos de ejecución para subagentes:
- fork — hereda el contexto padre, optimizado para caché
- teammate — panel separado en tmux o iTerm, se comunica mediante un buzón basado en archivos
- worktree — obtiene su propio git worktree, rama aislada por agente
Puedes decirle a Claude Code que active 5 agentes: uno haciendo una auditoría de seguridad, otro refactorizando el módulo de autenticación, otro escribiendo tests, otro actualizando la documentación, otro corrigiendo errores. Todos al mismo tiempo. Todos compartiendo la caché.
La arquitectura está CONSTRUIDA para esto. Usarlo en un solo hilo es un crimen.
3. El sistema de permisos está diseñado para configurarse, no para hacer clic en él
Cada vez que Claude Code pregunta "¿permitir esta acción?" y haces clic en sí, eso es un fallo de configuración, no una funcionalidad.
El código fuente revela una cascada de 5 niveles de configuración:
1política > flag > local > proyecto > usuario
En ~/.claude/settings.json puedes establecer patrones glob para lo que siempre está permitido:
1{2 "permissions": {3 "allow": [4 "Bash(npm *)",5 "Bash(git *)",6 "Edit(src/**)",7 "Write(src/**)"8 ]9 }10}
Hay tres modos de permiso:
- bypass — sin comprobaciones de permisos (peligroso pero rápido)
- allowEdits — permite automáticamente las ediciones de archivos en tu directorio de trabajo
- auto (esto es nuevo) — ejecuta un clasificador LLM en cada acción. Este es el punto óptimo.
El modo auto tiene sus propias listas de permitir/denegar que puedes configurar. El código fuente muestra que ejecuta múltiples resolvedores en paralelo: clic del usuario, clasificador de hooks, puente, y el primero en responder gana.
Cada vez que te detienes a hacer clic en "permitir" es tiempo perdido. Configúralo una vez. No vuelvas a hacer clic nunca más.
4. Hay 5 estrategias de compactación. La presión del contexto es un problema real
El código fuente tiene CINCO formas diferentes de comprimir tu conversación cuando se vuelve demasiado larga:
- microcompact — limpieza basada en tiempo de resultados de herramientas antiguas
- context collapse — resume fragmentos de la conversación
- session memory — extrae el contexto clave a un archivo
- full compact — resume todo el historial
- PTL truncation — elimina los grupos de mensajes más antiguos
Esto te dice algo importante: el desbordamiento de contexto es un problema central en el que los ingenieros pasaron MUCHO tiempo.
Lo que esto significa para ti:
- Usa
/compactde forma proactiva. No esperes a que el sistema se compacte automáticamente y pierdas contexto que te importa.
- La ventana predeterminada es de 200K tokens. Pero puedes optar por 1M de tokens usando el sufijo de modelo
[1m]. Para refactorizaciones grandes en muchos archivos, esto importa.
- Las sesiones largas acumulan "memoria de sesión": resúmenes estructurados de especificaciones de tareas, listas de archivos, estado del flujo de trabajo, errores y aprendizajes. Por eso reanudar una sesión es mejor que empezar de cero.
- Los resultados grandes de herramientas se almacenan en disco con solo una vista previa de 8KB enviada al modelo. Si pegas un archivo enorme, el modelo puede ver solo una fracción. Mantén las entradas enfocadas.
Las personas que más partido le sacan a Claude Code usan /compact como un punto de guardado manual en un videojuego. Preserva lo que importa, limpia lo que no, sigue adelante.
5. El sistema de hooks es la verdadera API de extensión (más de 25 eventos del ciclo de vida)
Esta es la función para usuarios avanzados que casi nadie conoce.
El código fuente revela más de 25 eventos del ciclo de vida en los que puedes engancharte:
- PreToolUse — se ejecuta antes de que cualquier herramienta se ejecute
- PostToolUse — se ejecuta después de que cualquier herramienta se ejecute
- UserPromptSubmit — se ejecuta cuando envías un mensaje
- SessionStart / SessionEnd — ciclo de vida de la sesión
- y más de 20 más
Con 5 tipos de hooks:
- command — ejecuta un comando de shell
- prompt — inyecta contexto a través de LLM
- agent — ejecuta un bucle de verificación de agente completo
- HTTP — llama a un webhook
- function — ejecuta JS
Ejemplos reales de lo que puedes hacer:
- Ejecutar linting automáticamente antes de cada escritura de archivo
- Ejecutar tests después de cada edición
- Inyectar documentación relevante en cada prompt automáticamente
- Enviar una notificación de Slack cuando una tarea se completa
- Validar que se siguen los patrones de seguridad antes de enviar código
El hook UserPromptSubmit es especialmente alucinante. Puedes inyectar additionalContext en cada mensaje que envías. Imagina adjuntar automáticamente la salida de tests, diffs recientes de git o el estado del proyecto a cada prompt sin tener que escribirlo.
Así es como construyes un entorno de desarrollo personalizado sobre Claude Code. No mejorando los prompts. Sino enganchándote al propio sistema.
6. Las sesiones son persistentes y reanudables (deja de empezar de cero)
Cada conversación se guarda como JSONL en
1~/.claude/projects/{hash}/{sessionId}.jsonl
El código fuente admite:
- --continue — reanuda tu última sesión
- --resume — elige una sesión pasada específica
- --fork-session — bifurca desde una conversación pasada (personalmente me encanta esto)
La extracción de la memoria de sesión preserva el contexto clave a través de las compactaciones: especificaciones de tareas, listas de archivos, estado del flujo de trabajo, errores y aprendizajes.
La mayoría empieza una nueva sesión cada vez que abre Claude Code. Esto es como cerrar tu IDE y volver a abrirlo desde cero cada hora. Todo el contexto sobre lo que estabas haciendo, lo que falló, lo que aprendiste — desaparecido.
Usa --continue. Siempre. Deja que el contexto se acumule. Deja que la memoria de la sesión acumule aprendizajes con el tiempo. El código fuente tiene literalmente infraestructura para esto. Úsala.
7. El sistema de herramientas ejecuta más de 60 herramientas con agrupación inteligente
Claude Code tiene más de 60 herramientas integradas. Pero la parte interesante es CÓMO las ejecuta.
El código fuente divide las llamadas a herramientas en dos categorías:
- concurrente — operaciones de solo lectura (leer archivos, buscar, globbing) se ejecutan en paralelo
- serial — operaciones de mutación (ediciones, escrituras, comandos bash) se ejecutan una a la vez
Esto significa que cuando Claude Code necesita leer 10 archivos para entender tu base de código, los lee los 10 simultáneamente. Pero cuando necesita editar 3 archivos, los hace uno a la vez para evitar conflictos.
Además de las herramientas integradas, puedes conectar servidores MCP que añaden más herramientas. El código fuente usa carga diferida. Las herramientas MCP solo se cargan cuando se necesitan, así que conectar 5 servidores MCP no ralentiza cada solicitud.
Y existe ToolSearch para el descubrimiento diferido de herramientas que el agente aún no conoce.
La conclusión práctica: si tu flujo de trabajo involucra sistemas externos (bases de datos, proveedores de nube, CI/CD), conecta servidores MCP para ellos. La arquitectura maneja la complejidad. Tú solo obtienes más capacidades.
8. La arquitectura de streaming hace que la interrupción sea barata
Todo el pipeline utiliza generadores asíncronos que emiten eventos individuales. Presionar Escape aborta limpiamente el flujo actual sin perder el contexto anterior.
Esto parece pequeño, pero cambia cómo deberías usar Claude Code.
No esperes una respuesta que sabes que va mal. Interrumpe inmediatamente y redirige. El código fuente está diseñado para esto. Tu contexto anterior se preserva. La respuesta interrumpida se descarta limpiamente. Penalización cero.
Piénsalo como programación en pareja. Si tu compañero empieza a ir por el camino equivocado, no esperas a que termine. Dices "en realidad, ve por aquí". Misma energía.
9. El sistema de reintentos es más sofisticado de lo que crees
El código fuente revela:
- 10 reintentos con backoff exponencial y jitter (base de 500ms)
- Renovación automática del token OAuth en 401/403
- Fallback de modelo: si Opus falla 3 veces con errores 529, automáticamente recurre a Sonnet
- Vigilante de inactividad de 90 segundos en streams — si el streaming se estanca, recurre a no-streaming
- El modo persistente tiene reintento infinito con un backoff máximo de 5 minutos
Esto significa que Claude Code está diseñado para dejarse ejecutando. Maneja los contratiempos de la API, los límites de tasa y las interrupciones con elegancia. No necesitas estar pendiente. Déjalo ejecutarse en segundo plano y vuelve a los resultados.
El resumen: acciones de mayor apalancamiento del código fuente:
• Escribe un CLAUDE.md real → se carga en cada turno. 40K caracteres. Configuración de mayor apalancamiento.
• Paraleliza con subagentes → el modelo fork comparte la caché de prompts. 5 agentes ≈ coste de 1.
• Configura permisos en settings.json → elimina la fatiga de clics para siempre.
• Usa /compact de forma proactiva → existen 5 estrategias de compactación porque la presión del contexto es real.
• Configura hooks → más de 25 eventos, 5 tipos. Esta es la verdadera API de extensión.
• Siempre usa --continue en las sesiones → persistencia JSONL + memoria de sesión = contexto acumulado.
• Conecta servidores MCP → la carga diferida significa coste cero hasta que se usan.
• Interrumpe libremente → los generadores asíncronos significan penalización cero por redirigir.
La conclusión final: Claude Code es una plataforma de orquestación de agentes con una interfaz de terminal.
Las personas que obtienen un rendimiento 10 veces mayor no son mejores escribiendo prompts. Lo configuraron. Lo paralelizaron. Se engancharon a él. Dejaron que el contexto se acumulara entre sesiones.
El código fuente lo hace obvio. Ahora sabes lo que realmente hace bajo el capó.
Rt si te ha resultado útil 🫶
