La mayoría de la gente abre Claude Code, escribe un prompt, espera la respuesta, escribe otro prompt.
Es como comprar un Ferrari y solo manejarlo en primera velocidad.
Quería entender por qué algunas personas parecen sacarle 10 veces más provecho a Claude Code que otras. Así que hice lo que cualquier persona razonable haría: 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 realmente esta cosa.
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 tiene o nada en su archivo CLAUDE.md o escribió toda la biblia ahí.
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— nivel de proyecto (decisiones de arquitectura, convenciones).claude/rules/*.md— reglas modularesCLAUDE.local.md— notas privadas (ignorado por git)
Tienes 40,000 caracteres. Eso es MUCHO. La mayoría usa quizás 200.
Pon tus decisiones de arquitectura ahí. Tus convenciones de archivos. Tus patrones de pruebas. 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 Claude Code sea TU asistente que conoce TU código.
Si haces una sola cosa después de leer esto, que sea esta.
2. Los subagentes comparten el caché de prompts (el paralelismo es básicamente gratis)
Esto es lo que me voló la cabeza.
Cuando Claude Code bifurca un subagente, crea una copia byte-idéntica del contexto padre. La API almacena esto en caché. Así que lanzar 5 agentes para trabajar en diferentes partes de tu código cuesta apenas más que 1 agente haciendo las cosas secuencialmente.
Léelo de nuevo.
5 agentes. Mismo costo que 1. Porque todos golpean el caché de prompts.
La mayoría usa Claude Code como un solo trabajador. Una tarea a la vez. Esperar a que termine. Darle la siguiente tarea.
El código fuente literalmente tiene 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 buzón basado en archivos
- worktree — obtiene su propio git worktree, rama aislada por agente
Puedes decirle a Claude Code que lance 5 agentes: uno haciendo una auditoría de seguridad, otro refactorizando el módulo de autenticación, otro escribiendo pruebas, otro actualizando la documentación, otro arreglando bugs. Todos al mismo tiempo. Todos compartiendo el caché.
La arquitectura está CONSTRUIDA para esto. Usarlo con un solo hilo es criminal.
3. El sistema de permisos está diseñado para configurarse, no para hacer clic todo el tiempo
Cada vez que Claude Code pregunta "¿Permitir esta acción?" y haces clic en sí, eso es una falla de configuración, no una funcionalidad.
El código fuente revela una cascada de configuración de 5 niveles:
1policy > flag > local > project > user
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 verificación de permisos (peligroso pero rápido)
- allowEdits — permite automáticamente ediciones de archivos en tu directorio de trabajo
- auto (esto es nuevo) — ejecuta un clasificador LLM en cada acción. Este es el punto ideal.
El modo auto tiene sus propias listas de permitir/denegar que puedes configurar. El código fuente muestra que ejecuta múltiples solucionadores en paralelo: clic del usuario, clasificador de hooks, bridge, y el primero en responder gana.
Cada vez que te detienes a hacer clic en "permitir" es tiempo perdido. Configúralo una vez. Nunca más hagas clic.
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 antiguos de herramientas
- context collapse — resume fragmentos de la conversación
- session memory — extrae 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 del 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 auto-compacte y pierda el contexto que te importa. - La ventana predeterminada es de 200K tokens. Pero puedes optar por 1M de tokens usando el sufijo
[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 es mejor reanudar una sesión que empezar de cero.
- Los resultados grandes de herramientas se almacenan en disco y solo se envía una vista previa de 8KB al modelo. Si pegas un archivo enorme, el modelo puede ver solo una fracción. Mantén las entradas enfocadas.
Las personas que obtienen el máximo provecho de Claude Code usan /compact como un punto de guardado manual en un videojuego. Preservan lo que importa, limpian lo que no, y siguen adelante.
5. El sistema de hooks es la verdadera API de extensión (25+ eventos del ciclo de vida)
Esta es la función para usuarios avanzados que casi nadie conoce.
El código fuente revela 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 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 pruebas después de cada edición
- Inyectar documentación relevante en cada prompt automáticamente
- Enviar una notificación de Slack cuando se complete una tarea
- Validar que se sigan los patrones de seguridad antes de enviar código
El hook UserPromptSubmit es especialmente loco. Puedes inyectar additionalContext en cada mensaje que envías. Imagina adjuntar automáticamente resultados de pruebas, diferencias de git recientes o estado del proyecto a cada prompt sin escribirlo.
Así es como construyes un entorno de desarrollo personalizado sobre Claude Code. No mejorando los prompts. Sino enganchándote al sistema mismo.
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 soporta:
- --continue — reanuda tu última sesión
- --resume — elige una sesión pasada específica
- --fork-session — bifurca desde una conversación anterior (personalmente me encanta esto)
La extracción de memoria de sesión preserva el contexto clave entre compactaciones: especificaciones de tareas, listas de archivos, estado del flujo de trabajo, errores y aprendizajes.
La mayoría de la gente inicia una nueva sesión cada vez que abre Claude Code. Esto es como cerrar tu IDE y reabrirlo desde cero cada hora. Todo el contexto sobre lo que estabas haciendo, lo que falló, lo que aprendiste — desapareció.
Usa --continue. Siempre. Deja que el contexto se acumule. Deja que la memoria de la sesión construya aprendizajes con el tiempo. El código fuente literalmente tiene infraestructura para esto. Úsala.
7. El sistema de herramientas ejecuta 60+ herramientas con agrupación inteligente
Claude Code tiene 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 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 agregan 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 hay ToolSearch para 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 generan 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. Sin penalización.
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í mejor". Misma energía.
9. El sistema de reintentos es más sofisticado de lo que crees
El código fuente revela:
- 10 reintentos con retroceso exponencial y jitter (500ms base)
- Actualización automática de token OAuth en 401/403
- Fallback de modelo: si Opus falla 3 veces con errores 529, automáticamente recurre a Sonnet
- Perro guardián de inactividad de 90 segundos en streams: si el streaming se detiene, recurre a no-streaming
- El modo persistente tiene reintento infinito con un retroceso máximo de 5 minutos
Esto significa que Claude Code está diseñado para dejarse ejecutando. Maneja problemas de API, límites de tasa y cortes de manera elegante. No necesitas estar pendiente. Déjalo ejecutarse en segundo plano y vuelve a los resultados.
El resumen: las 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 el caché de prompts. 5 agentes ≈ costo 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 → 25+ eventos, 5 tipos. Esta es la verdadera API de extensión.
• Siempre usa --continue para sesiones → persistencia JSONL + memoria de sesión = contexto acumulado.
• Conecta servidores MCP → la carga diferida significa costo cero hasta que se usen.
• 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 disfrazada de interfaz de terminal.
Las personas que obtienen un rendimiento 10 veces mayor no son mejores en escribir 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 resultó útil 🫶
