Capítulo 11: Optimización y Uso Eficiente

Duración: 60 minutos Dificultad: Intermedio-Avanzado

🎯 Objetivos de Aprendizaje

Al final de este capítulo, podrás:

Entender qué son los tokens y cómo funcionan los límites
Gestionar contexto eficientemente para minimizar costos
Escribir prompts optimizados que ahorran tokens
Comprender sesiones y su ciclo de vida
Aplicar estrategias de uso óptimo de herramientas
Adoptar filosofía de código agéntico
Implementar mejores prácticas para aprendizaje efectivo
Maximizar productividad mientras minimizas costos

📖 Lección 11.1: Entendiendo Tokens y Límites

¿Qué Son los Tokens?

Los tokens son las unidades básicas de texto que Claude procesa.

Regla aproximada:

1 token ≈ 4 caracteres en inglés
1 token ≈ ¾ de una palabra
100 tokens ≈ 75 palabras
1000 tokens ≈ 750 palabras

Ejemplos:

"Hola" = 1 token
"Claude Code" = 2 tokens
"Optimización de rendimiento" = 4-5 tokens

Contexto y Context Window

Context Window = Total de tokens disponibles para una conversación

Composición del Contexto:

Total: 200,000 tokens
├── System Prompt: ~2,000 tokens (1%)
├── System Tools: ~12,000 tokens (6%)
├── Memory Files: ~500 tokens (0.25%)
├── Messages: Variable (depende de conversación)
└── Free Space: Lo que queda disponible

Ver tu uso actual:

/context

Context Usage
████████████░░░░░░░░  60k/200k tokens (30%)

System prompt: 2.1k tokens (1.0%)
System tools: 11.8k tokens (5.9%)
Memory files: 516 tokens (0.3%)
Messages: 45.5k tokens (22.8%)
Free space: 140k (70.0%)

Límites y Qué Significan

Context Window:

Claude Sonnet 4: 200,000 tokens
Es tu "espacio de trabajo" total
Incluye TODA la conversación + system prompts + herramientas

Autocompact Buffer:

~45,000 tokens (22.5% del total)
Cuando lo alcanzas, Claude compacta automáticamente
Mantiene información importante, resume el resto

¿Qué pasa cuando llegas al límite?

1. Autocompact se activa → Compacta mensajes antiguos
2. Si sigue lleno → Claude sugiere /compact o /clear
3. Si alcanzas límite absoluto → Debes empezar nueva sesión

Costos por Tokens

Claude Code usa el API de Claude, que tiene costos:

Ejemplo de costos (aproximados):

Input: $3 por millón de tokens
Output: $15 por millón de tokens

Ver costos de tu sesión:

/cost

Total session cost: $0.45
Input tokens: 50,000 ($0.15)
Output tokens: 20,000 ($0.30)

Implicaciones:

Conversaciones largas = más caro
Muchos archivos leídos = más caro
Output verbose = más caro
Uso eficiente = ahorras dinero

📖 Lección 11.2: Gestión de Contexto

Estrategias para Liberar Contexto

1. Comando /compact

/compact

✅ Mantiene: Información importante, decisiones key, código reciente
❌ Descarta: Conversación repetitiva, debugging resuelto, exploración antigua

Resultado: 80k → 45k tokens (ahorro de 35k)

Cuándo usar /compact:

Cada 30-45 minutos de trabajo intenso
Antes de empezar nueva feature grande
Cuando /context muestre >60% de uso
Después de debugging largo

2. Comando /clear

/clear

Limpia TODA la conversación
Empieza completamente fresco

Cuándo usar /clear:

Cambiar a proyecto completamente diferente
Después de completar una tarea major
Cuando el contexto ya no es relevante
Para empezar sesión de debugging fresca

3. Reiniciar Sesión

/exit
claude

Nueva sesión, contexto vacío

Cuándo reiniciar:

Después de varias horas de trabajo
Cuando /compact ya no ayuda mucho
Para máxima eficiencia en nueva tarea

Optimal Session Length

Recomendación:

30-90 minutos por sesión para tareas enfocadas
Compact cada 30-45 minutos
Nueva sesión después de 2-3 horas

Anti-pattern: Sesiones Infinitas

❌ 8 horas sin compact
- Contexto saturado
- Claude pierde foco
- Respuestas menos efectivas
- Costos innecesarios

Best Practice: Sesiones Focalizadas

✅ Sesión 1 (90 min): Implementar feature X
   /compact a los 45 min
   Terminar y /exit

✅ Sesión 2 (60 min): Debuggear issue Y
   /compact si es necesario
   Terminar y /exit

✅ Sesión 3 (45 min): Code review
   Sin compact necesario
   /exit al terminar

📖 Lección 11.3: Prompts Eficientes

Anatomía de un Buen Prompt

Elementos:

Contexto: Qué estás tratando de lograr
Acción: Qué quieres que Claude haga
Restricciones: Limitaciones o preferencias
Formato: Cómo quieres la respuesta

Prompts Token-Efficient

❌ Verbose e Ineficiente:

Hola Claude, espero que estés bien. Estoy trabajando en este proyecto y me preguntaba si podrías ayudarme. Verás, tengo este archivo llamado auth.js y creo que hay un bug en alguna parte, no estoy seguro dónde exactamente pero parece que tiene que ver con la validación de tokens, ¿podrías por favor revisar el archivo completo y decirme si ves algún problema? También sería genial si pudieras explicarme qué está mal y cómo arreglarlo paso por paso si encuentras algo. Gracias de antemano por tu ayuda.

Tokens: ~120

✅ Conciso y Eficiente:

Debuggea auth.js: posible bug en validación de tokens. Identifica el problema y propón fix.

Tokens: ~20
Ahorro: 100 tokens (83%)

Principios de Prompts Eficientes

1. Sé Directo

❌ "Me pregunto si sería posible que..."
✅ "Por favor..."

❌ "¿Crees que podrías ayudarme a..."
✅ "Ayúdame a..."

2. Omite Cortesías Innecesarias

❌ "Hola, buenos días, espero que estés bien..."
✅ [directo a la tarea]

❌ "Gracias de antemano por tu ayuda..."
✅ [agregar "gracias" al final si quieres, pero no es necesario]

3. Usa Abreviaciones Cuando Sea Claro

✅ "Lee README.md y resume en 3 puntos"
✅ "Fix typo en línea 45"
✅ "Add tests para getUserData()"

4. Referencias Precisas

❌ "El archivo que mencioné antes"
✅ "src/auth.js"

❌ "Esa función de la que hablamos"
✅ "getUserData() en user.service.ts"

5. Batch Requests

❌ "Lee file1.js"
    "Lee file2.js"
    "Lee file3.js"

✅ "Lee file1.js, file2.js, file3.js"

Prompts para Diferentes Contextos

Research/Exploración (puede ser más verbose):

✅ "Explica el patrón Observer con ejemplos y casos de uso"

Implementación (debe ser conciso):

✅ "Implementa Observer pattern en TypeScript"

Debugging (específico y directo):

✅ "Error en línea 67: 'undefined is not a function'. Fix."

📖 Lección 11.4: Uso Óptimo de Herramientas

Jerarquía de Eficiencia

De más eficiente a menos eficiente:

Herramientas Especializadas (Más eficiente)
- Read, Edit, Glob, Grep
- Diseñadas para propósito específico
- Mínimo overhead
Bash para Operaciones del Sistema
- Git, npm, build tools
- Cuando es la herramienta correcta
Agentes (Usar con criterio)
- Para investigación compleja
- Cuando múltiples intentos son necesarios
- Contexto separado = overhead adicional
Repetir Información (Menos eficiente)
- Copiar/pegar mismo código múltiples veces
- Explicar mismo concepto repetidamente

Decision Tree: ¿Qué Herramienta Usar?

¿Necesitas leer archivo?
  ├─ Sabes path exacto? → Read
  └─ No sabes path? → Glob, luego Read

¿Necesitas modificar archivo?
  ├─ Cambio específico? → Edit
  └─ Reescribir completo? → Write

¿Necesitas buscar contenido?
  ├─ En archivos específicos (2-3)? → Read + analizar
  └─ En muchos archivos? → Grep

¿Necesitas investigar/explorar?
  ├─ Búsqueda simple? → Grep/Glob
  ├─ Múltiples archivos desconocidos? → Agent
  └─ Análisis profundo? → Agent

¿Necesitas ejecutar comando?
  ├─ Terminal operation? → Bash
  └─ File operation? → Usa herramienta específica

Optimizaciones Concretas

1. Leer Solo Lo Necesario

❌ Ineficiente:
Read entire file (2000 lines)
Look at lines 50-60 only

✅ Eficiente:
Read file with offset=49, limit=11

2. Filtrar Búsquedas

❌ Ineficiente:
Grep "pattern" en todos los archivos
Filter results manualmente

✅ Eficiente:
Grep "pattern" type="js" glob="src/**"

3. Ejecución Paralela

❌ Secuencial (lento):
Read file1 → wait
Read file2 → wait
Read file3 → wait

✅ Paralelo (rápido):
Read file1, file2, file3 simultáneamente

4. Agentes: Solo Cuando Sea Necesario

❌ Uso innecesario:
Agent para leer archivo conocido

✅ Uso apropiado:
Agent para buscar implementación desconocida en codebase grande

📖 Lección 11.5: Filosofía de Código Agéntico

¿Qué es Código Agéntico?

Código Agéntico es desarrollo donde confías en agentes de IA (como Claude) para hacer trabajo pesado, mientras tú diriges y validas.

Principios del Desarrollo Agéntico

1. Tú Eres el Arquitecto

Tu rol:
- Definir qué construir
- Tomar decisiones de arquitectura
- Validar resultados
- Guiar dirección

Claude's rol:
- Implementar
- Sugerir best practices
- Ejecutar tareas repetitivas
- Encontrar bugs

2. Delegar Efectivamente

✅ Buena delegación:
"Implementa autenticación JWT con refresh tokens"

❌ Micro-management:
"Primero importa jwt, luego crea función llamada generateToken, debe tomar userId como parámetro, usar secret de env..."

3. Trust but Verify

Después de implementación:
1. Revisa código generado
2. Ejecuta tests
3. Verifica que cumple requerimientos
4. Itera si es necesario

4. Iteración Rápida

Ciclo agéntico:
1. Prompt claro → 2. Claude implementa → 3. Tú validas → 4. Refinas

No buscar perfección en primera iteración

Mindset para Desarrollo Agéntico

Cambio de Paradigma:

Desarrollo Tradicional:

Tú escribes cada línea
Tú debuggeas cada error
Tú buscas cada solución
Tiempo: 100% implementación

Desarrollo Agéntico:

Tú defines qué construir (20%)
Claude implementa (60% del tiempo)
Tú validas y refinas (20%)
Tiempo: 40% dirección, 60% validación

Resultado:

3-5x más rápido
Más tiempo para diseño y arquitectura
Menos tiempo en tareas repetitivas
Foco en problemas de alto nivel

Habilidades Clave para Código Agéntico

1. Prompt Engineering

Comunicar intención claramente
Proporcionar contexto necesario
Saber cuándo ser específico vs general

2. Code Review

Leer código rápidamente
Identificar issues potenciales
Entender implicaciones de decisiones

3. Testing

Definir casos de test importantes
Validar comportamiento esperado
Identificar edge cases

4. Arquitectura

Diseñar sistemas escalables
Tomar decisiones de alto nivel
Mantener visión del proyecto

📖 Lección 11.6: Mejores Prácticas de Aprendizaje

Estrategias para Aprender Efectivamente

1. Aprender Haciendo

✅ Activo:
"Implementa X" → Observa cómo Claude lo hace → Aprende el patrón

❌ Pasivo:
"Explícame X" → Lees → Olvidas

2. Pedir Explicaciones Después

Flujo óptimo:
1. "Implementa feature X"
2. Claude implementa
3. "Explica por qué usaste este patrón en línea 45"
4. Aprendes en contexto real

3. Experimentar Sin Miedo

Es OK pedir:
- "Prueba approach diferente"
- "¿Qué pasa si...?"
- "Muestra 3 maneras de hacer esto"

Claude no juzga, usa esto para explorar

4. Construir Progresivamente

Simple → Intermedio → Avanzado

No saltar directo a lo más complejo

5. Crear Proyectos Personales

Aprenderás más construyendo:
- Tu propio portfolio
- CLI tool que uses
- App que resuelva tu problema

Que haciendo tutoriales genéricos

Técnicas de Aprendizaje Avanzadas

A. Feynman Technique con Claude

1. Aprende concepto con Claude
2. "Explícame X como si tuviera 10 años"
3. Si Claude lo explica claramente, lo entiendes
4. Si no, profundiza más

B. Learning by Comparison

"Muestra 3 formas de implementar caching:
1. In-memory
2. Redis
3. File-based

Explica pros/cons de cada una"

C. Debugging como Aprendizaje

Cuando algo falla:
1. Intenta arreglarlo tú primero
2. Luego pide ayuda a Claude
3. Compara tu approach con el de Claude
4. Aprende de las diferencias

D. Code Review Reverso

1. Escribe código tú
2. "Revisa este código como senior engineer"
3. Aprende de feedback
4. Mejora

Hábitos de Developers Exitosos con IA

1. Diario de Aprendizaje

Después de cada sesión:
- ¿Qué aprendí hoy?
- ¿Qué patrón nuevo vi?
- ¿Qué haría diferente la próxima vez?

2. Collección de Snippets

Guarda patrones útiles que Claude genera:
- Configuraciones
- Snippets de código
- Comandos útiles

3. Iteración Constante

No te conformes con primera versión
Pregunta: "¿Cómo mejorarías esto?"

4. Balance IA/Manual

Usa IA para: Boilerplate, scaffolding, exploración
Haz manual: Lógica de negocio crítica, decisiones de arquitectura

📖 Lección 11.7: Optimización de Costos

Strategies para Minimizar Costos

1. Sesiones Enfocadas

✅ Eficiente:
- Sesión corta y enfocada
- Una tarea a la vez
- /exit cuando terminas

❌ Ineficiente:
- Sesión de 8 horas
- Saltas entre múltiples tareas
- Contexto crece indefinidamente

2. Usar /compact Proactivamente

Compactar cada 30-45 minutos:
- Previene autocompact forzado
- Mantiene conversación relevante
- Reduce tokens en mensajes futuros

3. Leer Solo Lo Necesario

❌ Costoso:
"Lee todos los archivos en src/"

✅ Económico:
"Lee src/auth/login.ts"

4. Output Conciso

✅ "Resume cambios en 3 puntos"
✅ "Lista solo archivos modificados"

❌ "Explica detalladamente todo lo que cambiaste"

5. Usar Agentes Estratégicamente

Agente = Contexto separado = Costo adicional

Solo usar cuando:
- Necesitas investigación profunda
- Múltiples intentos probables
- Quieres preservar contexto main

6. Cachear Información

En lugar de preguntar repetidamente:
1. Pide información una vez
2. Guárdala en archivo
3. Referencia el archivo después

Costo por Tipo de Tarea

Bajo Costo:

Comandos directos: "Edit line 45"
Lecturas específicas: "Read file.js"
Operaciones simples

Medio Costo:

Implementaciones medianas
Code review
Debugging guiado

Alto Costo:

Investigación extensa
Múltiples agentes
Conversaciones muy largas sin compact
Reescrituras completas

ROI (Return on Investment)

Calcular valor:

Tiempo ahorrado × Tu tarifa por hora > Costo de Claude

Ejemplo:
Claude ahorra 4 horas en proyecto
Tu tarifa: $50/hora
Ahorro: $200

Costo Claude: $2-5
ROI: $195-198 (4000% ROI)

📖 Lección 11.8: Checklist de Eficiencia

Pre-Sesión

¿Sé exactamente qué quiero lograr?
¿Tengo contexto necesario preparado?
¿Es una tarea que vale la pena usar Claude?
¿He limpiado sesión anterior si es necesario?

Durante Sesión

¿Estoy siendo específico en mis prompts?
¿Uso herramientas especializadas vs bash?
¿Ejecuto operaciones en paralelo cuando sea posible?
¿He compactado si uso >60% de contexto?
¿Estoy delegando efectivamente?

Post-Sesión

¿Completé la tarea?
¿Aprendí algo nuevo?
¿Hay patrones que pueda reutilizar?
¿Debo crear comando slash para esto?
¿Terminé la sesión o la dejé abierta?

Optimización Continua

¿Mis sesiones son <90 minutos?
¿Uso /context regularmente?
¿Reviso /cost periódicamente?
¿Estoy mejorando en prompt engineering?
¿He creado herramientas para tareas repetitivas?

🛠️ Ejercicios de Práctica

Ejercicio 11.1: Análisis de Contexto

Ejecuta /context y analiza tu uso actual
Ejecuta /cost y ve cuánto has gastado
Identifica qué consume más tokens
Experimenta con /compact
Compara contexto antes y después

Ejercicio 11.2: Prompt Optimization

Toma estos prompts verbose y optimízalos:

Original 1: "Hola Claude, espero que estés teniendo un buen día. Me preguntaba si podrías ayudarme con algo. Necesito que leas el archivo llamado config.json que está en la carpeta raíz del proyecto y me digas qué configuraciones tiene. Sería genial si pudieras explicarme qué hace cada una."

Tu versión optimizada: [escribe aquí]

Original 2: "Tengo un problema con mi código. Hay un error en algún lugar pero no sé exactamente dónde. ¿Podrías revisar el archivo user-service.ts completo y decirme si ves algo mal? También me gustaría que me explicaras qué está causando el problema y cómo podríamos arreglarlo."

Tu versión optimizada: [escribe aquí]

Ejercicio 11.3: Tool Selection

Para cada tarea, indica la herramienta MÁS eficiente:

Leer archivo cuyo path exacto conoces: ______
Buscar palabra "TODO" en 50 archivos: ______
Encontrar implementación de función desconocida: ______
Modificar línea específica en archivo: ______
Crear archivo completamente nuevo: ______
Ejecutar tests: ______

Ejercicio 11.4: Session Management

Trabaja en una tarea por 45 minutos
Usa /context cada 15 minutos y anota el uso
Usa /compact a los 45 minutos
Nota la diferencia en tokens
Reflexiona: ¿Cuándo deberías compactar?

📝 Examen 11: Maestría en Optimización

Parte 1: Preguntas Teóricas (5 puntos)

Pregunta 1: Explica qué son los tokens y aproximadamente cuántos tokens hay en 1000 palabras.

Pregunta 2: ¿Cuál es el context window de Claude Sonnet 4 y qué incluye?

Pregunta 3: ¿Cuándo deberías usar /compact vs /clear?

Pregunta 4: Explica la filosofía de "código agéntico" en tus propias palabras.

Pregunta 5: Nombra 3 estrategias concretas para reducir costos al usar Claude Code.

Parte 2: Optimization Challenge (5 puntos)

Escenario: Tienes una sesión con 75% de contexto usado y necesitas implementar 3 features más.

¿Qué harías primero? ¿Por qué?
Propón una estrategia para completar las 3 features eficientemente
¿Cuándo compactarías? ¿Cuándo iniciarías nueva sesión?

Parte 3: Prompt Engineering (5 puntos)

Optimiza estos prompts manteniendo la intención:

1. Verbose prompt (80+ tokens): "Buenos días Claude, espero que estés bien. Estoy trabajando en este proyecto de React y me gustaría que me ayudaras con algo. Verás, tengo un componente que se llama UserProfile y necesito agregar funcionalidad para que el usuario pueda editar su perfil. Específicamente, necesito un formulario con campos para nombre, email y bio. ¿Podrías por favor ayudarme a implementar esto? Sería genial si pudieras usar TypeScript y agregar validación básica también. Muchas gracias por tu ayuda."

Tu versión (objetivo: <25 tokens):

2. Prompt ineficiente: "Necesito que hagas lo siguiente: primero lee el archivo auth.js, luego lee el archivo middleware.js, luego lee el archivo routes.js, y después de que leas todos esos archivos, busca la función llamada validateToken y dime en cuál de los archivos está y qué hace."

Tu versión (más eficiente):

Parte 4: Proyecto de Optimización (5 puntos + Bonus)

Tarea: Audita tu propio uso de Claude Code

Revisa tus últimas 3-5 sesiones (si tienes historiales exportados)
Identifica:
- Prompts ineficientes que usaste
- Momentos donde no usaste la herramienta óptima
- Oportunidades de crear comandos slash
- Situaciones donde deberías haber compactado
Crea un "plan de optimización personal":
- 3 cosas que harás diferente
- 2 comandos slash que crearás
- 1 agente que te ayudaría

Bonus (+3 puntos): Implementa tu plan de optimización:

Crea los 2 comandos slash
Crea el agente
Demuestra mejora en eficiencia en una tarea real
Compara tokens/costo antes vs después

✅ Cómo Enviar Tu Examen

Para Partes 1-3:

Parte 1:
P1: [respuesta]
...

Parte 2:
[tu estrategia]

Parte 3:
1. [prompt optimizado]
2. [prompt optimizado]

Para Parte 4:

Comparte tu análisis de auditoría
Presenta tu plan de optimización
Si hiciste el bonus, demuestra las implementaciones y resultados

🎯 ¡Felicitaciones! Has Completado el Curso

Has dominado:

✅ Fundamentos de Claude Code
✅ Operaciones con archivos
✅ Flujos de trabajo Git
✅ Herramientas avanzadas
✅ Comandos slash personalizados
✅ Agentes y sub-agentes
✅ Hooks y automatización
✅ Estilos de salida
✅ Integración MCP
✅ Flujos de trabajo avanzados
✅ Optimización y eficiencia

🚀 Próximos Pasos

Practica Regularmente
- Usa Claude Code en proyectos reales
- Experimenta con features avanzadas
- Itera y mejora tu workflow
Comparte Conocimiento
- Enseña a otros
- Crea tus propios recursos
- Contribuye a la comunidad
Mantente Actualizado
- Claude Code se actualiza frecuentemente
- Lee release notes
- Prueba nuevas features
Continúa Aprendiendo
- Explora MCP servers
- Crea agentes especializados
- Optimiza continuamente

📚 Recursos Adicionales

Documentación Oficial:

https://docs.claude.com/en/docs/claude-code/

Comunidad:

GitHub Issues para reportar bugs
Discord/Forums para discusiones

Tu Mejor Recurso:

¡Claude mismo! Pregunta cualquier duda

🎓 Certificado de Completion

Has completado exitosamente el Curso Maestro de Claude Code.

Ahora eres capaz de:

Desarrollar 3-5x más rápido con IA
Optimizar costos y eficiencia
Implementar proyectos complejos
Aplicar mejores prácticas profesionales
Enseñar a otros sobre Claude Code

¡Felicitaciones por tu dedicación y aprendizaje! 🎉

Anterior: capitulo_10.md

Curso creado con ❤️ usando Claude Code

FilesExpand file tree

capitulo_11.md

Latest commit

History