Model Selection y Effort Level

Descripción

Tienes Claude Code instalado, autenticado, y con el plan correcto. Ahora viene la configuración que separa al usuario casual del profesional: elegir el modelo correcto y la profundidad de razonamiento para cada tarea.

Claude Code te da acceso a la familia Claude 5 — Opus 5, Sonnet 5, y Haiku 4.5 para el trabajo diario, más Fable 5 para las tareas de frontera — y un ajuste de effort level que controla cuánto razona Claude antes de responder. La combinación de modelo + effort es tu herramienta más poderosa para balancear calidad, velocidad, y costo. Usar Opus + high effort para una tarea trivial es desperdiciar recursos. Usar Sonnet + low effort para una decisión de arquitectura es comprometer calidad.

En esta cápsula vas a aprender cuándo usar cada modelo, cómo funciona cada nivel de effort, y las combinaciones óptimas para los escenarios más comunes de desarrollo. Al terminar, sabrás ajustar modelo y effort en tiempo real según lo que necesites, maximizando tu productividad y tu cuota.

Los Modelos Disponibles

Opus 5

┌─────────────────────────────────────────────┐
│  OPUS 5                                     │
│                                             │
│  Tipo:      Modelo flagship de Anthropic    │
│  Contexto:  1M tokens                       │
│  Output:    128K tokens máximo              │
│  Velocidad: Más lento que Sonnet            │
│  Costo:     Mayor consumo de cuota          │
│  Fuerza:    Razonamiento profundo           │
│                                             │
│  Ideal para:                                │
│  → Arquitectura de sistemas                 │
│  → Refactoring multi-archivo               │
│  → Code review profundo                    │
│  → Análisis de codebases grandes           │
│  → Decisiones complejas                    │
│  → Debugging difícil                       │
└─────────────────────────────────────────────┘

1M de contexto: Opus 5 puede procesar hasta 1 millón de tokens de contexto. En términos prácticos, puede "ver" un codebase completo de tamaño mediano-grande de una sola vez. Sonnet 5 también soporta 1M tokens.

128K de output: Puede generar respuestas extremadamente largas — refactorings completos de múltiples archivos, documentación extensiva, o análisis detallados.

Razonamiento profundo: Opus piensa más antes de responder. No solo genera texto — analiza, planifica, considera edge cases, y produce soluciones más robustas.

Sonnet 5

┌─────────────────────────────────────────────┐
│  SONNET 5                                   │
│                                             │
│  Tipo:      Modelo rápido y eficiente       │
│  Contexto:  1M tokens                      │
│  Output:    128K tokens máximo              │
│  Velocidad: Significativamente más rápido   │
│  Costo:     Menor consumo de cuota          │
│  Fuerza:    Velocidad + eficiencia          │
│                                             │
│  Ideal para:                                │
│  → Quick fixes y cambios puntuales         │
│  → Creación de archivos simples            │
│  → Preguntas directas                      │
│  → Formatting y renaming                   │
│  → Tareas repetitivas                      │
│  → Generación de boilerplate               │
└─────────────────────────────────────────────┘

Velocidad: Sonnet responde notablemente más rápido que Opus. Para tareas donde la velocidad importa más que la profundidad de análisis, Sonnet es la elección correcta.

Eficiencia: Consume menos cuota. Si estás en Pro y cuidas tu cuota de Opus, Sonnet te permite seguir trabajando sin restricciones.

Calidad: No es "inferior" en todo — para tareas simples y moderadas, Sonnet produce resultados idénticos a Opus. La diferencia se nota en tareas que requieren razonamiento multi-paso o análisis extenso.

Haiku 4.5

┌─────────────────────────────────────────────┐
│  HAIKU 4.5                                  │
│                                             │
│  Tipo:      Modelo más rápido y económico   │
│  Contexto:  200K tokens                    │
│  Output:    64K tokens máximo               │
│  Velocidad: El más rápido de la familia     │
│  Costo:     Mínimo consumo de cuota         │
│  Fuerza:    Velocidad + costo-eficiencia    │
│                                             │
│  Ideal para:                                │
│  → Preguntas simples y directas            │
│  → Tareas mecánicas (renaming, formatting) │
│  → Generación de boilerplate básico        │
│  → Verificaciones rápidas                  │
│  → Tareas donde el costo importa más       │
│    que la profundidad                       │
└─────────────────────────────────────────────┘

Velocidad: Haiku es el modelo más rápido de la familia Claude. Responde casi instantáneamente para tareas simples.

Costo-eficiencia: Consume significativamente menos cuota que Sonnet. Si estás cuidando tu cuota y la tarea es simple, Haiku es la elección óptima.

Limitaciones: Para tareas que requieren razonamiento complejo, análisis multi-archivo, o decisiones de arquitectura, Haiku no es suficiente. Usa Sonnet o Opus para esas tareas.

Fable 5: el tier de frontera

┌─────────────────────────────────────────────┐
│  FABLE 5                                    │
│                                             │
│  Tipo:      Modelo más capaz de Anthropic   │
│  Contexto:  1M tokens                       │
│  Velocidad: El más lento (piensa más)       │
│  Costo:     El más alto de la familia       │
│  Fuerza:    Razonamiento de frontera y      │
│             trabajo agentic de largo alcance │
│                                             │
│  Ideal para:                                │
│  → Los problemas de razonamiento más duros │
│  → Sesiones agentic largas y autónomas     │
│  → Cuando la correctitud vale más que el   │
│    costo o la velocidad                     │
└─────────────────────────────────────────────┘

Fable 5 es el modelo más capaz de Anthropic disponible ampliamente. En Claude Code lo seleccionas con el alias fable (/model fable). No es el modelo del día a día: cuesta bastante más que Opus y piensa más tiempo. Resérvalo para las tareas donde la calidad del razonamiento justifica el costo — un debugging que nadie más resuelve, una migración crítica, una sesión agentic larga que no puedes supervisar paso a paso. Para el 95% del trabajo diario, Opus 5, Sonnet 5 y Haiku 4.5 son la elección correcta.

Comparación directa

Alias opusplan: Claude Code ofrece un alias especial que usa Opus para planificación (plan mode) y automáticamente cambia a Sonnet para ejecución. Es la forma más eficiente de combinar ambos modelos: /model opusplan.

Cómo Cambiar de Modelo

Comando /model

Dentro de una sesión de Claude Code:

> /model

Te muestra los modelos disponibles y te permite seleccionar. Usa aliases (opus, sonnet, haiku, fable) o nombres completos (claude-opus-5, claude-sonnet-5, claude-haiku-4-5, claude-fable-5):

> /model sonnet
✓ Switched to sonnet

> /model opus
✓ Switched to opus

> /model haiku
✓ Switched to haiku

Cambio durante la sesión

Puedes cambiar de modelo en cualquier momento sin perder el contexto de la conversación:

> /model opus
✓ Switched to opus

> "Analiza la arquitectura de este proyecto y sugiere mejoras"
[Claude responde con análisis profundo de Opus]

> /model sonnet
✓ Switched to sonnet

> "Renombra 'getData' a 'fetchUserData' en src/api.ts"
[Claude responde rápidamente con Sonnet]

El contexto de la conversación se mantiene al cambiar de modelo. Solo cambia el "cerebro" que procesa tu siguiente mensaje. También puedes cambiar modelo con Option+P (macOS) o Alt+P (Windows/Linux) sin borrar tu prompt.

Modelo por defecto

Configura el modelo predeterminado de varias formas:

# Al iniciar la sesión
claude --model opus

# Por variable de entorno
export ANTHROPIC_MODEL=opus

# En settings (permanente) — abre /config
# Establece "model": "opus"

El modelo default varía según tu tipo de cuenta: Pro y Team Standard usan Sonnet 5; Max, Team Premium y el uso pay-as-you-go de la API usan Opus 5.

El alias opusplan

opusplan es un modo híbrido automático que no requiere cambiar modelo manualmente:

/model opusplan

En Plan mode → Usa Opus (razonamiento profundo para planificar)
En ejecución → Cambia automáticamente a Sonnet (eficiencia para implementar)

Es la forma más eficiente de combinar lo mejor de ambos modelos.

Cuándo Usar Cada Modelo

Opus 5: El pensador profundo

Usa Opus cuando la tarea requiere razonamiento complejo, visión amplia, o decisiones con consecuencias:

Arquitectura y diseño:

> /model opus
> "Evalúa nuestra arquitectura de microservicios. 
   ¿Deberíamos consolidar los servicios de auth y users? 
   Analiza trade-offs."

Opus puede evaluar el impacto en múltiples servicios, considerar edge cases de migración, y proporcionar una recomendación fundamentada.

Refactoring multi-archivo:

> /model opus
> "Refactoriza el módulo de payments para usar el nuevo 
   patrón de Strategy en vez de switch cases. 
   Afecta 8 archivos."

Opus mantiene coherencia entre archivos, entiende dependencias, y aplica el patrón consistentemente.

Code review profundo:

> /model opus
> "Revisa los cambios del PR #47. Busca bugs potenciales, 
   problemas de performance, y violaciones de nuestras 
   convenciones."

Opus analiza cada cambio en contexto, identifica bugs sutiles, y evalúa el impacto en el sistema completo.

Debugging complejo:

> /model opus
> "Los tests de integración fallan intermitentemente en CI 
   pero nunca en local. El error es un timeout en la conexión 
   a Redis. Ayúdame a encontrar la causa raíz."

Opus puede razonar sobre race conditions, diferencias de entorno, y problemas de concurrencia.

Análisis de codebases grandes:

> /model opus
> "Acabo de clonar este monorepo de 50K líneas. 
   Mapea la arquitectura: servicios, dependencias, 
   y puntos de entrada."

Con 1M de contexto, Opus puede procesar codebases enteras y generar mapas arquitecturales.

Sonnet 5: El ejecutor rápido

Usa Sonnet cuando la tarea es clara, acotada, y no requiere razonamiento profundo:

Quick fixes:

> /model sonnet
> "Hay un typo en la línea 42 de src/utils/format.ts: 
   'lenght' debería ser 'length'"

Creación de archivos simples:

> /model sonnet
> "Crea un archivo .gitignore para un proyecto Python con FastAPI"

Formatting y boilerplate:

> /model sonnet
> "Genera los types de TypeScript para este JSON response"

Preguntas directas:

> /model sonnet
> "¿Cuál es la sintaxis de un GROUP BY con HAVING en PostgreSQL?"

Tareas repetitivas:

> /model sonnet
> "Agrega JSDoc a todas las funciones exportadas en src/utils/"

Renaming y refactoring simple:

> /model sonnet
> "Renombra el archivo user-service.ts a user.service.ts 
   y actualiza todos los imports"

Haiku 4.5: El ultraligero

Usa Haiku cuando la tarea es trivial, mecánica, o cuando necesitas maximizar la eficiencia de cuota:

Preguntas simples:

> /model haiku
> "¿Existe el archivo src/config.ts?"

Verificaciones rápidas:

> /model haiku
> "¿Cuántos archivos .py hay en el proyecto?"

Formatting básico:

> /model haiku
> "Convierte este JSON a YAML"

Renaming mecánico:

> /model haiku
> "Renombra la variable 'x' a 'count' en este archivo"

Haiku no es el modelo correcto para tareas que requieren comprensión profunda del codebase, decisiones de diseño, o análisis multi-archivo. Para eso, usa Sonnet o Opus.

La zona gris

Algunas tareas están en el medio. Para estas, la regla es:

¿La tarea tiene múltiples pasos que dependen entre sí?
├─ Sí → Opus
└─ No → Sonnet

¿Necesito que Claude considere edge cases que yo podría no ver?
├─ Sí → Opus
└─ No → Sonnet

¿La respuesta incorrecta tendría consecuencias difíciles de revertir?
├─ Sí → Opus
└─ No → Sonnet

¿La tarea toca más de 3 archivos?
├─ Sí → Opus (probablemente)
└─ No → Sonnet (probablemente)

Effort Level

Qué es

El effort level controla la profundidad del razonamiento adaptativo de Claude (adaptive reasoning). Con effort bajo, Claude responde rápido y directo. Con effort alto, razona extensivamente antes de responder.

Effort está soportado en los modelos de la familia Claude 5 que razonan — Opus 5, Sonnet 5 y Fable 5 (y Opus 4.8). Los cinco niveles están disponibles en todos ellos:

Haiku 4.5 no expone effort configurable: está optimizado para responder rápido en tareas simples. Si configuras un nivel de effort mientras usas Haiku, Claude Code simplemente lo ignora.

El default

El default en los modelos que soportan effort es high. Es un buen punto de partida para la mayoría del trabajo. Para coding y tareas agentic, xhigh suele ser la mejor opción: piensa más antes de actuar, lo que reduce los idas y vueltas. Ajústalo con /effort según la tarea.

Los 5 niveles

Importante: low, medium, high, y xhigh persisten entre sesiones. max provee el razonamiento más profundo sin restricción de tokens y aplica solo a la sesión actual (excepto cuando se configura via CLAUDE_CODE_EFFORT_LEVEL).

low ─── medium ─── high ─── xhigh ─── max
 │        │          │        │         │
 Rápido Balance   Default  Recomendado Sin límite
                           en coding

Cómo configurar

Hay varias formas de ajustar el effort level:

1. Comando /effort (la más directa):

> /effort low
> /effort medium
> /effort high
> /effort xhigh
> /effort max
> /effort auto    # reset al default del modelo

Ejecuta /effort sin argumentos para abrir un slider interactivo. El nivel actual se muestra junto al logo (por ejemplo "with xhigh effort").

2. En /model con flechas:

> /model
[Selecciona el modelo]
[Usa ← → para ajustar effort]

3. Flag al iniciar:

claude --effort high

4. En settings (permanente):

{
  "effortLevel": "medium"
}

5. Por variable de entorno:

export CLAUDE_CODE_EFFORT_LEVEL=low   # o medium, high, xhigh, max, auto

6. Tip rápido — "ultrathink": Incluye "ultrathink" en tu prompt para activar effort high solo para ese turno, sin cambiar tu configuración de sesión.

Fast Mode

Fast mode es una optimización de velocidad para Claude Opus 5. No cambia a un modelo diferente — es el mismo Opus 5 con output optimizado para ser más rápido. Es un research preview: su disponibilidad y pricing pueden cambiar, y hoy funciona solo en Opus 5 y Opus 4.8.

Qué es

Fast mode prioriza la velocidad de generación sobre la profundidad máxima de razonamiento. Claude sigue siendo Opus — con toda su capacidad y context window de 1M tokens — pero genera respuestas más rápido.

Cómo activarlo

> /fast

El comando /fast funciona como toggle: lo ejecutas una vez para activarlo, otra vez para desactivarlo.

Cuándo usarlo

Lo que Fast Mode NO es

Fast mode ≠ modelo diferente
Fast mode ≠ Sonnet
Fast mode ≠ menor capacidad

Fast mode = Opus 5 optimizado para velocidad de output

Importante: Si necesitas un modelo más ligero (y no solo output más rápido), usa Sonnet o Haiku en su lugar con /model sonnet o /model haiku. Fast mode es para cuando quieres la capacidad de Opus pero con respuestas más rápidas.

Fast mode vs Effort level

Fast mode y effort level son controles complementarios pero diferentes:

Puedes combinarlos: Opus con effort high + fast mode activado te da razonamiento profundo con output rápido.

La Combinación: Modelo + Effort

La matriz de decisiones

La combinación de modelo y effort te da un espectro de configuraciones:

                    Effort (Opus y Sonnet)
              low     medium    high     xhigh    max
           ┌───────┬────────┬────────┬────────┬────────┐
Opus 5     │  ⚡   │   ⚙️    │  🧠    │  🧠➕   │ 🧠🧠   │
           │rápido │balance │default │coding  │sin lím.│
           └───────┴────────┴────────┴────────┴────────┘
           ┌───────┬────────┬────────┬────────┬────────┐
Sonnet 5   │  ⚡   │   ⚙️    │  🧠    │  🧠➕   │ 🧠🧠   │
           │rápido │balance │default │coding  │sin lím.│
           └───────┴────────┴────────┴────────┴────────┘

Haiku 4.5  → Sin effort configurable
               (el más rápido y económico)

⚡ = rapidez priorizada
⚙️ = balance
🧠 = razonamiento profundo (default)
🧠➕ = recomendado para coding

Las 5 combinaciones más útiles

La mayoría del tiempo estarás entre Haiku/Sonnet (tareas rápidas) y Opus + xhigh (análisis profundo). El alias opusplan automatiza esa alternancia.

Matriz de Decisión Práctica

Task → Model + Effort

Patrón de un día típico

9:00  Standup prep      → Sonnet         (resumir cambios)
9:30  Verificaciones    → Haiku          (¿tests pasan? ¿qué branch?)
9:35  Implementación    → Sonnet         (endpoints, tests)
11:00 Code review       → Opus + xhigh   (buscar bugs en PR)
12:00 Decisión de arq.  → Opus + xhigh   (Redis vs Memcached)
2:00  Implementación    → Sonnet         (cache layer)
4:00  Quick fixes       → Haiku/Sonnet   (typos, renaming, versiones)

El modelo y effort cambian según la tarea. Esto es lo que hace un profesional — no usa la misma configuración para todo.

Implicaciones de Costo

Modelo + Effort → Consumo de cuota

Consumo relativo de cuota (aproximado):

Haiku            ██░░░░░░░░░░░░░░░░░░  (~0.5x)
Sonnet           ████░░░░░░░░░░░░░░░░  (~1x)

Opus + low       ████████░░░░░░░░░░░░  (~3x)
Opus + high      ████████████░░░░░░░░  (~5x)
Opus + xhigh     ████████████████████  (~8-10x)

Esto significa: Una tarea con Opus + xhigh effort consume ~8-10x más cuota que la misma tarea con Sonnet. Elegir la combinación correcta es la forma más efectiva de optimizar tu cuota. (Fable 5 está por encima de todo esto: es el modelo más caro de la familia — resérvalo para lo que de verdad lo amerita.)

Implicación práctica

Plan Pro (base):
→ Si usas Sonnet todo el día: ~6-8 horas de uso
→ Si usas Opus + xhigh todo el día: ~1-2 horas de uso
→ Si mezclas inteligentemente: ~4-6 horas de uso

Plan Max 5x:
→ 5x más cuota en cada escenario
→ Mezcla inteligente: ~20-30 horas de uso por período

Comparaciones y Decisiones

¿Opus siempre es mejor que Sonnet?

No. Para tareas simples (crear archivos, renaming, preguntas directas), Sonnet produce resultados idénticos más rápido y con menor costo. Opus se justifica cuando la tarea requiere razonamiento multi-paso, análisis extenso, o manejo de edge cases sutiles.

¿Puedo usar Opus + xhigh siempre?

Puedes, pero desperdicias 8-10x más cuota en tareas que no lo necesitan. Adaptar modelo + effort por tarea es la forma más inteligente de usar tu cuota: Sonnet donde importa velocidad, Opus + xhigh donde importa calidad.

¿Cuándo cambiar modelo vs bajar effort?

Resultado insuficiente con Sonnet:

La tarea es clara pero necesita más análisis
→ Cambia a Opus (y sube effort a xhigh si es necesario)

El resultado es excesivo / demasiado lento con Opus:
→ Baja effort a medium o low

Tarea simple pero quieres contexto profundo:
→ Opus + low

Patterns Comunes

Pattern 1: Empezar bajo, subir si hace falta

# Intenta primero con Sonnet (rápido y eficiente)
> "Implementa validación de email en el schema de usuario"

# Si el resultado no es suficiente:
> /model opus
> "Mejora la validación. Considera edge cases como 
   emails con caracteres especiales, dominios inválidos, 
   y longitud máxima según RFC 5321."

Esto es más eficiente que empezar con Opus + xhigh para todo.

Pattern 2: Bloque de tareas con mismo config

# Bloque de implementación (múltiples tareas similares)
> /model sonnet

> "Crea el endpoint GET /api/products"
> "Crea el endpoint POST /api/products"
> "Crea el endpoint PUT /api/products/:id"
> "Agrega tests para los 3 endpoints"

# Bloque de review (cambio de config)
> /model opus

> "Revisa los 4 archivos que acabamos de crear"

Agrupa tareas por nivel de complejidad para minimizar cambios de config.

Pattern 3: Opus para planificar, Sonnet para ejecutar

# Opción A: Manual
> /model opus
> "Planifica la migración de nuestra autenticación de 
   sessions a JWT. Dame un plan paso a paso con archivos 
   que necesitan cambiar."

> /model sonnet
> "Ejecuta el paso 1 del plan: crear el módulo jwt-utils.ts"
> "Paso 2: modificar el middleware de auth"
> "Paso 3: actualizar los tests"

# Opción B: Automático con opusplan
> /model opusplan
> "Migra la autenticación de sessions a JWT"
# Claude usa Opus para planificar, Sonnet para ejecutar — automáticamente

Opus planifica, Sonnet ejecuta. Con opusplan, ni siquiera tienes que cambiar manualmente.

Pattern 4: Sonnet para verificaciones rápidas

> /model sonnet
> "¿El archivo src/config.ts existe?"
> "¿Cuántos tests tenemos?"
> "¿Qué versión de Python dice pyproject.toml?"

> /model opus
> "Ahora diseña la migración..."

Para preguntas factuales y verificaciones, Sonnet responde correctamente sin necesidad de razonamiento profundo.

Pattern 5: Sesión de debugging escalonada

# Primer intento: entiende el problema
> /model sonnet
> "Los tests de user.service.test.ts fallan. ¿Por qué?"

# Si Sonnet no lo resuelve: escala a Opus
> /model opus
> "No encontraste la causa. El error es intermitente. 
   Analiza posibles race conditions o dependencias de estado."

# Opus con high effort (default) ya analiza exhaustivamente
# Si quieres más profundidad para un problema esquivo:
# Sube a xhigh en /effort

Pitfalls y Edge Cases

Pitfall 1: Usar Opus para todo

❌ /model opus
> "Crea un archivo README.md vacío"
→ Opus piensa profundamente sobre... un archivo vacío
→ Desperdicio de cuota y tiempo

Usa Sonnet para tareas simples — produce el mismo resultado más rápido y barato.

Pitfall 2: Usar Sonnet para tareas que requieren razonamiento profundo

❌ /model sonnet
> "Refactoriza el sistema de autenticación completo"
→ Sonnet trabaja bien pero puede perder edge cases sutiles
→ Puedes subir effort a xhigh, pero para tareas de esta complejidad Opus es mejor opción

Para tareas complejas, el costo extra de Opus + xhigh se justifica.

Pitfall 3: No cambiar nunca de configuración

❌ Todo el día con el mismo modelo y effort
→ Sobreutilizas cuota en tareas simples
→ O subutilizas capacidad en tareas complejas

Adaptar modelo + effort es como cambiar de marcha al conducir. No usas primera en la autopista ni quinta en un estacionamiento.

Pitfall 4: Asumir que effort afecta la "inteligencia" del modelo

El effort level no hace que el modelo sea "más inteligente." Controla cuánto razona antes de responder. Opus con effort low sabe lo mismo que con effort xhigh — la diferencia es cuánto analiza antes de darte la respuesta.

Effort low:   Claude sabe la respuesta pero la da rápido sin pensar mucho
Effort xhigh: Claude sabe lo mismo pero piensa extensivamente, 
              considerando alternativas, edge cases, y consecuencias

Pitfall 5: Olvidar cambiar de modelo entre tareas

Si usas Opus para una tarea de arquitectura y luego pides algo trivial sin cambiar a Sonnet, desperdicias cuota:

> /model opus
> "Diseña la arquitectura del sistema" ← Opus, correcto
> "Crea un .gitignore"                 ← Opus, innecesario

Desarrolla el hábito de cambiar modelo al cambiar de tipo de tarea. O usa opusplan para que Claude alterne automáticamente.

Ejemplo Completo Integrado

Escenario: Sesión de 2 horas implementando notifications

$ claude

# 1. Orientación (Sonnet) — 2 min
> /model sonnet
> "Resume qué cambió desde ayer"

# 2. Planificación (Opus) — 10 min
> /model opus
> "Planifica el sistema de notificaciones: archivos, dependencias, pasos"

# 3. Implementación (Sonnet) — 45 min
> /model sonnet
> "Crea email.service.ts" → "Crea notification.html"
> "Crea endpoint POST /notifications/send" → "Crea tests"

# 4. Verificación (Sonnet) — 5 min
> "Ejecuta tests y dime si pasan"

# 5. Review del trabajo (Opus) — 15 min
> /model opus
> "Revisa todo. ¿Bugs? ¿Convenciones? ¿Error handling?"

# 6. Correcciones + cleanup (Sonnet) — 13 min
> /model sonnet
> "Aplica correcciones 1, 3, 5" → "Lint + format"

# 7. Resumen (Sonnet)
> "Resume en 5 bullets para standup" → /exit

Alternativa con opusplan: Toda la sesión con /model opusplan. Claude usa Opus automáticamente cuando planifica y Sonnet cuando ejecuta. Menos cambios manuales, mismo resultado.

Resultado: ~70% Sonnet, ~30% Opus. Si todo hubiera sido Opus + xhigh, habría consumido ~4x más cuota con resultados similares.

Ejercicios Prácticos

Ejercicio 1: Experimenta con los niveles de effort

Haz la misma pregunta con cada nivel de effort en Opus y compara:

> /model opus
Pregunta: "Explica cómo funciona el event loop de Node.js"

# Ajusta effort con /effort low
> [observa la respuesta]

# Ajusta a medium
> [observa la respuesta]

# Ajusta a high (default)
> [observa la respuesta]

Ejercicio 2: Compara Opus vs Sonnet en la misma tarea

Pide lo mismo con cada modelo (mismo effort):

Tarea: "Sugiere 3 mejoras de performance para este proyecto"

> /model sonnet
> /effort high
> "Sugiere 3 mejoras de performance"

> /model opus
> /effort high
> "Sugiere 3 mejoras de performance"

Ejercicio 3: Encuentra el nivel mínimo efectivo

Para cada una de estas tareas, encuentra la combinación modelo + effort más baja que produce un resultado aceptable:

1. Crear un archivo .editorconfig
2. Escribir una función de validación de contraseñas
3. Explicar un bug en tu código
4. Planificar un refactoring de 5 archivos

Ejercicio 4: Sesión con cambios de modelo

Ejecuta una mini-sesión de 15 minutos donde cambies de modelo al menos 3 veces, según la tarea:

1. Pregunta rápida (Sonnet)
2. Implementación simple (Sonnet)
3. Review del resultado (Opus)
4. Corrección y cleanup (Sonnet)

> /model sonnet
> "¿Cuántos archivos .ts hay en src/?"

> "Crea una función utilitaria que formatee fechas en formato ISO"

> /model opus
> "Revisa la función que acabamos de crear. 
   ¿Maneja correctamente timezones? ¿Edge cases?"

> /model sonnet
> "Aplica las correcciones del review"

Ejercicio 5: Calcula el ahorro de una sesión optimizada

Compara (mentalmente) el costo de cuota entre:

Escenario A: Opus + max para todo durante 2 horas Escenario B: Mezcla inteligente (como en el ejemplo integrado) durante 2 horas

Resumen

• La familia Claude 5: Opus 5 (flagship, 1M contexto, 128K output), Sonnet 5 (rápido, balanceado, 1M contexto, 128K output), y Haiku 4.5 (el más rápido y económico, 200K contexto, 64K output). Más Fable 5 (fable), el modelo de frontera para lo más duro — premium en costo.
• Cambiar modelo: /model durante la sesión o Option+P/Alt+P — el contexto se mantiene
• Opus para: Arquitectura, refactoring grande, code review, debugging complejo, análisis de codebase
• Sonnet para: Quick fixes, boilerplate, implementación estándar, preguntas, tareas repetitivas
• Haiku para: Preguntas triviales, verificaciones rápidas, formatting básico, tareas donde el costo importa más
• 5 niveles de effort (Opus 5, Sonnet 5, Fable 5): low → medium → high (default) → xhigh (recomendado para coding) → max
• Effort se configura con /effort, en /model (flechas ← →), --effort flag, settings (effortLevel), o env var (CLAUDE_CODE_EFFORT_LEVEL)
• opusplan: Alias que usa Opus para planificar y Sonnet para ejecutar automáticamente
• Adapta por tarea: Cambiar modelo es como cambiar de marcha — hazlo según el terreno
• Empezar con Haiku/Sonnet, escalar a Opus si hace falta: Más eficiente que empezar en Opus siempre
• Ahorro real: Una mezcla inteligente consume ~3-4x menos cuota que usar Opus + xhigh para todo

Siguiente módulo: Módulo 03 - CLAUDE.md y el sistema de memoria — ahora que tienes Claude Code configurado con el modelo correcto, el siguiente paso es darle contexto sobre tu proyecto para que sus respuestas sean aún más precisas.

Recursos Adicionales

1. Model Configuration — Modelos disponibles, aliases, effort levels, contexto extendido, y opusplan
2. Fast Mode — Cómo funciona fast mode y cuándo usarlo
3. Claude Code Settings — Configurar modelo y effort por defecto
4. Claude Code CLI Reference — Referencia completa de comandos y flags
5. Manage Costs — Optimización de costos, model selection, y reduce token usage
6. Claude Models — Especificaciones y pricing por token de cada modelo