Una de las mejores características de nuestros modelos Claude más recientes es cómo responden al esfuerzo sin romper la caché del prompt 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 siquiera?
Para responder a esto, decidí hacer un análisis profundo de las evaluaciones (evals) y realizar mis propias pruebas de esfuerzo aplicadas a tareas cotidianas.
nota: puedes ver diagramas interactivos y explicaciones adicionales para esta publicación en https://claude.dev/blog/spending-your-effort/
A grandes rasgos, descubrí que el esfuerzo es una excelente forma de ajustar cuánta verificación y pruebas de casos límite realiza Claude, y cuánto recurre a su propio criterio.
Un esfuerzo adicional arrojó 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 resultó perfecto para avanzar rápido y mantenerme involucrado en el proceso junto a Claude.
Para la ingeniería de software habitual, ahora sigo este ciclo: primero 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ánta capacidad de cómputo quieres que dedique a la tarea. Está relacionado, en cierta medida, con tu propia percepción de la dificultad de esa tarea.
Piénsalo así: si alguien te pidiera trabajar 12 horas seguidas en algo, probablemente asumirías que solo quiere que lo hagas y que pongas todo tu empeño. Si te pidiera lo mismo pero en 1 hora, intentarías entregarle la mejor versión posible que cumpla con lo solicitado y esperarías iterar a partir de ahí.
O tal vez pondrías límites 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á completar tu tarea de forma razonable, pero un nivel de esfuerzo más alto hará que tome 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 se observa un aumento tanto en las puntuaciones de los benchmarks como en los tokens consumidos. A continuación, muestro un gráfico con las puntuaciones de Terminal Bench 3.0 según el esfuerzo, medidas durante las evaluaciones que hice para este artículo.
Pero, ¿qué significa esto en la práctica? Para averiguarlo, probé varias tareas con distintos niveles de esfuerzo y analicé a fondo los benchmarks.
Desarrollando 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 realizaba. Lo hice con una gran variedad de proyectos, pero aquí lo ilustraré con algunos ejemplos sencillos.
Tarea de desarrollo poco definida
Si le pido a Claude que "construya una app personal para registrar entrenamientos y estado físico", el esfuerzo cambia drásticamente lo completa que queda la aplicación, y también hace que Claude tome más decisiones por el camino. 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 incluso un mapa de calor.
Si buscara una base sencilla sobre la cual iterar, el esfuerzo bajo haría el trabajo. El esfuerzo máximo sería ideal si quisiera el mejor resultado posible de Claude en un solo intento.
Tarea de diseño ligeramente definida
¿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. Cada intento 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 fiel a Claude Code, junto con varios recorridos explicativos para diferentes flujos.
Si mi objetivo fuera iterar y dar feedback, el esfuerzo bajo llegaría ahí 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 muy definida
¿Y si le doy a Claude muchos detalles? Intenté pedirle 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 indicaciones tan precisas, los modelos se comportaban de forma mucho más similar. Obtuve diseños bastante parecidos y con implementaciones equivalentes, aunque con detalles distintos; con esfuerzo máximo, Claude se tomó un tiempo para simplificar algunos de esos detalles.
Conclusiones clave
Para la ingeniería de software habitual, especialmente al desarrollar nuevas funcionalidades, el nivel de esfuerzo depende mucho de qué tan involucrado quiera estar en el proceso. El esfuerzo bajo permite que Claude responda rápidamente con un punto de partida; los niveles más altos logran que haga más trabajo, pero también asumen más cosas por mí.
Un ciclo que me ha resultado muy productivo para desarrollar funcionalidades es el siguiente:
- Darle a Claude unas especificaciones y pedirle que me entreviste sobre cualquier detalle que falte
- Implementarlo con esfuerzo bajo
- Revisar para asegurarme de que captó bien la idea general e iterar con esfuerzo bajo según sea necesario
- Verificar y probar con esfuerzo alto
Cómo afectan los niveles de esfuerzo al resultado en tareas difíciles
Estos son, evidentemente, ejemplos sencillos que Claude puede resolver sin problemas. Pero ¿qué ocurre cuando la diferencia está entre que Claude complete 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 generales 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 hacerse una idea del tipo de problemas a los que se 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 retos a los que yo me enfrentaría.
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 inmersión de Takens en Lean 4.
- ML (mp-checkpoint-consolidation): fusionar 16 fragmentos de un checkpoint de mezcla de expertos (mixture-of-experts) en un único 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 esfuerzo mayor 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 cualquier forma de inyectar JavaScript en una página. Fable 5.1 pasó de 1/5 con esfuerzo bajo a 5/5 con esfuerzo xhigh.
Un intento típico con esfuerzo bajo toma unos 2 minutos. En cada uno de estos intentos, el modelo 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, ese 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 la optimización de rendimiento o las revisiones de seguridad.
Pero no necesitas este nivel de esfuerzo para todas las tareas.
El siguiente diagrama muestra todos los resultados de Terminal-Bench 3.0 y cómo fallaron, 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 soluciona los casos en los que el modelo adopta un enfoque equivocado (bloques azules).
Áreas problemáticas donde el esfuerzo marca la diferencia
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 en los que Opus 5.5 falló con esfuerzo bajo, pero triunfó 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 del motor de almacenamiento a partir de su informe de fallos, sin romper la compactación. Opus 5.5 pasó de 0/5 con esfuerzo bajo a 4/5 con esfuerzo 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 comprobaba si su nueva prueba habría detectado el bug original.
Con esfuerzo xhigh (unos 11 minutos), Claude primero reprodujo el fallo, escribió una prueba aleatorizada comparándola con una referencia que nunca compacta, y verificó que sus pruebas fallaran con correcciones incompletas.
cli-2ph-simple: es una tarea de Terminal-Bench 3.0 que pide un solver de programación lineal por línea de comandos 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 comprobaron con unos pocos 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 verificó.
Durante los intentos con esfuerzo alto, Claude probó su solver con problemas aleatorios frente a otro solver independiente de fuerza bruta, luego midió el tiempo de los más grandes, encontró casos que tardaban demasiado o fallaban, y rehízo su búsqueda.
gsea-proteomics: una tarea de Terminal-Bench 3.0 que solicita 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ó el motivo antes de elegir la correcta.
Si un usuario hubiera estado involucrado en el proceso, Claude quizá 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 cuándo usar cada nivel de esfuerzo:
- Bajo: cuando quiero respuestas rápidas manteniéndome involucrado en el proceso, por ejemplo, para lluvias 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 trabajos donde la verificación es importante o hay casos límite, por ejemplo, corregir un bug en un código legacy (brownfield).
- 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 a variar el esfuerzo para Opus 5.5 y Fable 5.1 según tu tarea, o incluso en mitad de una conversación, usando /effort en Claude Code, y cuéntame si coincide con tu intuición.
