Una de las mejores características de nuestros modelos Claude más recientes es cómo responden al esfuerzo sin romper la caché de prompts en Claude Code, pero he recibido muchas preguntas de los usuarios sobre este tema. ¿Qué es realmente el esfuerzo y cuándo conviene usar cada nivel? ¿Por qué lo necesitamos?
Para responder esto, decidí hacer una inmersión profunda en las evaluaciones (evals) y realizar mis propias pruebas de esfuerzo en tareas cotidianas.
nota: puedes ver más diagramas interactivos y explicaciones para esta publicación en https://claude.dev/blog/spending-your-effort/
A grandes rasgos, descubrí que el esfuerzo es una excelente manera de ajustar cuánta verificación y pruebas de casos límite realiza Claude, y cuánto usa su propio criterio.
El esfuerzo adicional dio mejores resultados en áreas donde la verificación y las pruebas de casos límite son más útiles, como hardware, revisión de código y seguridad.
Pero el esfuerzo bajo y medio fue perfecto para resolver cosas rápido y mantenerme involucrado en el proceso junto a Claude.
Para la ingeniería de software habitual, ahora uso un ciclo: le pido al modelo que me entreviste, luego implemento con esfuerzo bajo o medio, reviso lo que construyó y finalmente ejecuto la verificación con esfuerzo alto.
¿Qué es el esfuerzo?
En términos generales, el esfuerzo le da al modelo una aproximación de cuánto cómputo quieres que dedique a la tarea. Está relacionado, en cierta medida, con tu percepción de la dificultad de esa tarea.
Piénsalo así: si alguien te pide que hagas algo trabajando 12 horas seguidas, probablemente asumas que solo quiere que lo hagas y que te esfuerces al máximo. Si te pide la misma tarea pero en 1 hora, intentarías entregarle la mejor versión posible que cumpla con el objetivo y esperarías iterar a partir de ahí.
O tal vez te resistirías y dirías que la tarea requiere al menos 3 horas, y trabajarías esas 3 horas para entregarla.
Deberías pensar en el esfuerzo de la misma manera. Claude siempre intentará hacer tu tarea de forma razonable, pero un mayor esfuerzo implica que tomará más decisiones por su cuenta para evaluar y verificar.
Curvas de esfuerzo
Las curvas de esfuerzo de Fable 5.1 y Opus 5.5 son las mejores hasta ahora; en cada nivel hay un aumento tanto en las puntuaciones de los benchmarks como en los tokens consumidos. A continuación, verás un gráfico de las puntuaciones de Terminal Bench 3.0 según el esfuerzo, medidas durante mis evaluaciones para esta publicación.
Pero, ¿qué significa esto en la práctica? Para evaluarlo, probé varias tareas con distintos niveles de esfuerzo y analicé los benchmarks a fondo.
Construir con esfuerzo
La mejor manera de entender cómo funcionan los modelos es experimentar. Probé hacer las mismas tareas con varios niveles de esfuerzo en Opus 5.5 para comprender el trabajo que realizaría. Lo hice con una gran variedad de tareas, pero aquí lo ilustro con algunos ejemplos sencillos.
Tarea de desarrollo poco especificada
Si le pido a Claude que "construya una app personal para registrar entrenamientos y estado físico", el esfuerzo cambia drásticamente qué tan completa queda la aplicación, y también hace que Claude tome más decisiones durante el proceso. Con esfuerzo bajo, la app de fitness es solo un registro y un gráfico simple. Con niveles de esfuerzo más altos, la app se vuelve más compleja y detallada. Con esfuerzo máximo, incluye un mapa de calor.
Si quisiera una base simple para iterar después, el esfuerzo bajo haría el trabajo. El esfuerzo máximo sería ideal si quiero el mejor resultado posible de Claude en un solo intento.
Tarea de diseño ligeramente especificada
¿Qué pasa si tengo una tarea ya bastante definida, pero quiero explorar opciones con Claude? Como ejemplo, le pedí que rediseñara el menú /config en Claude Code. En cada pasada tuvo básicamente la misma idea: usar submenús y mejorar la búsqueda.
Con esfuerzo bajo (que tomó 1 minuto), obtuve un boceto interactivo que transmitía la idea, pero no se parecía mucho a Claude Code.
Con esfuerzo máximo (que tomó 28 minutos), obtuve un mockup muy similar a Claude Code, junto con varios recorridos para diferentes flujos.
Si mi objetivo fuera iterar y dar feedback, el esfuerzo bajo llegaría mucho más rápido. Pero el esfuerzo máximo me entrega algo mucho más pulido desde el primer momento. Para esta tarea en particular, creo que prefiero usar esfuerzo bajo para entender la visión de Claude.
Tarea de desarrollo altamente especificada
¿Y si le doy a Claude muchos detalles? Le pedí que me entrevistara a fondo sobre la app de fitness y luego usé esas especificaciones para que distintos modelos las implementaran con diferentes niveles de esfuerzo.
Descubrí que, con estas especificaciones, los modelos se comportaron de manera mucho más similar. Obtuvimos diseños bastante parecidos y con implementaciones similares, aunque con distintos detalles; con esfuerzo máximo, Claude se tomó un tiempo para simplificar algunos de esos detalles.
Conclusiones clave
Para la ingeniería de software del día a día, especialmente al desarrollar nuevas funcionalidades, el nivel de esfuerzo depende mucho de qué tan involucrado quiera estar. El esfuerzo bajo permite que Claude responda rápido con un punto de partida; los niveles más altos logran avanzar más, pero Claude también tomará más decisiones por mí.
Un ciclo que me ha dado muy buenos resultados para desarrollar features es el siguiente:
- Dale a Claude una especificación y pídele que te entreviste sobre cualquier detalle que falte
- Impleméntala con esfuerzo bajo
- Revísala para asegurarte de que captó bien la idea general e itera con esfuerzo bajo según sea necesario
- Verifica y prueba con esfuerzo alto
Cómo impactan los niveles de esfuerzo en los resultados de tareas difíciles
Obviamente, estos son ejemplos sencillos que Claude puede completar sin problema. Pero, ¿qué pasa cuando la diferencia está entre que Claude termine la tarea o no?
Para encontrar estos problemas difíciles hay que ir a los benchmarks, así que me sumergí en uno que me gusta: Terminal Bench 3, un benchmark creado por la comunidad.
Los problemas de Terminal-Bench 3.0 se pueden dividir en categorías como seguridad, hardware, ML, ciencia, software, operaciones y medios. Puedes ver todos los problemas aquí: https://github.com/harbor-framework/terminal-bench/releases/tag/v3.0.0; provienen de la comunidad, así que cualquiera puede contribuir.
Vale la pena leerlos para darte una idea del tipo de problemas que enfrentan estos modelos. Me sorprendió el alcance y la ambición de muchas de estas tareas. Son mucho más complicadas que el promedio de los retos a los que me enfrento.
Por ejemplo, algunas de las tareas incluían:
- Hardware (retro-console-soc): construir una consola de juegos de 8 bits en Verilog que quepa en una FPGA pequeña y renderice una ROM de prueba.
- Ciencia (takens-embedding-lean): demostrar formalmente el teorema de embedding de Takens en Lean 4.
- ML (mp-checkpoint-consolidation): fusionar 16 fragmentos de un checkpoint mixture-of-experts en un solo archivo que reproduzca los logits de referencia.
- Operaciones (intrastat-meldung): ejecutar de principio a fin la declaración mensual de estadísticas comerciales de la UE de una empresa.
- Medios (layout-config-recreation): reconstruir la imagen de un póster como un archivo de diseño editable.
Los niveles de esfuerzo más altos ayudan cuando hay muchos casos límite
Mi principal conclusión tras revisar los resultados de Terminal Bench 3 fue que un mayor esfuerzo es ideal para tareas con muchos casos límite ocultos.
Un ejemplo claro es html-js-filter, una tarea de Terminal-Bench 3.0 que pide crear un sanitizador HTML que elimine todas las formas posibles de inyectar JavaScript en una página. Fable 5.1 pasó de 1/5 con esfuerzo bajo a 5/5 con xhigh.
Un intento típico con esfuerzo bajo toma unos 2 minutos. Cada uno de estos intentos escribió un filtro prácticamente de una sola pasada y luego lo probó contra una única página escrita a mano.
Una ejecución con esfuerzo alto termina en unos 33 minutos. En la ejecución que analicé, el modelo revisó su primer borrador buscando vulnerabilidades, luego leyó el código fuente del parser instalado para buscar errores, ejecutó muchos casos de prueba limpios hasta que dieron el mismo resultado que la entrada, corrió una suite estándar de pruebas XSS y, finalmente, escribió un fuzzer de documentos aleatorios.
Para algo con tantos casos límite como un sanitizador HTML, este esfuerzo extra vale totalmente la pena. Gastar más tokens para ser exhaustivo también tiene sentido en tareas complejas con altos requisitos de producción, como optimización de rendimiento o revisiones de seguridad.
Pero no necesitas este nivel de esfuerzo para todo.
El siguiente diagrama muestra cada resultado de Terminal-Bench 3.0 y cómo falló, en distintos modelos y niveles de esfuerzo. En general, aumentar el esfuerzo tiende a reducir los fallos por casos límite omitidos (bloques morados), pero no corrige los casos en los que el modelo elige un enfoque equivocado (bloques azules).
Áreas problemáticas donde el esfuerzo ayuda
Una de las conclusiones más interesantes que saqué al evaluar estos modelos en TerminalBench fue que ciertas áreas problemáticas se beneficiaban del esfuerzo mucho más que otras. Puedes ver el desglose en el siguiente diagrama:
Para ilustrarlo, elegí algunos problemas de distintas áreas de Terminal Bench 3.0 donde Opus 5.5 falló con esfuerzo bajo, pero lo logró con esfuerzo alto, principalmente porque probó y contempló los casos límite:
mvcc-lsm-compaction: una tarea de Terminal-Bench 3.0 que pide corregir un bug de un motor de almacenamiento a partir de su reporte de fallo, sin romper la compactación. Opus 5.5 pasó de 0/5 con esfuerzo bajo a 4/5 con xhigh.
Con esfuerzo bajo (aproximadamente un minuto por intento), Claude editaba el código antes de compilarlo o de ejecutar el reproductor del error, y no verificaba si su nueva prueba habría detectado el bug original.
Con xhigh (unos 11 minutos), Claude primero reprodujo el fallo, escribió una prueba aleatorizada contra una referencia que nunca compacta, y comprobó que sus pruebas fallaban con correcciones incompletas.
cli-2ph-simple: es una tarea de Terminal-Bench 3.0 que pide un solver CLI de programación lineal escrito en Python. Opus 5.5 pasó de 0/5 con esfuerzo bajo a 5/5 con esfuerzo alto.
Los intentos con esfuerzo bajo escribieron un solver de una sola pasada, lo probaron con algunos problemas pequeños y se detuvieron alrededor de los 10k tokens. En el mensaje final, Claude advirtió que podría ser lento con problemas grandes, pero no lo comprobó.
Durante los intentos con esfuerzo alto, Claude probó su solver con problemas aleatorios comparándolo contra otro solver de fuerza bruta independiente, luego midió el tiempo de problemas más grandes, encontró casos que tardaban demasiado o fallaban, y reformuló su búsqueda.
gsea-proteomics: una tarea de Terminal-Bench 3.0 que pide un análisis de enriquecimiento de conjuntos de genes (GSEA) sobre datos proteómicos para descubrir cuál de ocho tratamientos se asemeja a un tejido objetivo. Opus 5.5 pasó de 0/5 con esfuerzo bajo a 4/5 con esfuerzo alto.
Con esfuerzo bajo, Claude eligió una forma de preparar los datos que sonaba razonable, ejecutó el análisis de esa única manera y reportó el resultado.
Con esfuerzo alto, Claude probó dos formas de preparar los datos, notó que la lista de tratamientos significativos cambiaba e investigó por qué antes de elegir la correcta.
Si un usuario hubiera estado involucrado, Claude quizás le habría preguntado cómo configurar el problema, pero sin intervención humana, el esfuerzo alto funciona mejor.
Cuándo usar cada nivel de esfuerzo en Claude Code
Esta es mi regla general sobre qué nivel de esfuerzo usar y cuándo:
- Bajo: cuando quiero respuestas rápidas y mantenerme involucrado en el proceso, por ejemplo, para lluvia de ideas, bocetos o cambios sencillos.
- Medio: para la mayor parte de mi trabajo diario de ingeniería de software, por ejemplo, implementar nuevas funcionalidades.
- Alto: para tareas donde la verificación es importante o hay casos límite, por ejemplo, corregir un bug en un codebase legacy.
- Máximo: cuando quiero que Claude opere de forma totalmente autónoma para resolver problemas difíciles, por ejemplo, construir y verificar una app de principio a fin, o encontrar vulnerabilidades de seguridad en software crítico.
Prueba variar el esfuerzo para Opus 5.5 y Fable 5.1 según tu tarea, o incluso en plena conversación usando /effort en Claude Code, y cuéntame si coincide con tu intuición.
