Mejor IA para programar: los benchmarks no ven tu código

Qwen3.6, un modelo que corre en mi escritorio, sacó 50 % y 60 % en dos benchmarks públicos de programación que corrí yo mismo, en mi equipo. Después le di 27 tareas sacadas de mi propio código, con tests que ya existían. Resolvió 6: el 22 %. Probé cinco agentes distintos y ninguna combinación pasó de 3 tareas de 8. Si estás eligiendo la mejor IA para programar, el ranking te dice poco de cómo le va a ir con tu código.

¿Qué dicen los benchmarks públicos?

La pregunta que quería responder era concreta: ¿puedo delegar trabajo de código a un modelo local en vez de a Claude Code con Opus 5.5, que es lo que uso todos los días?

Tengo un DGX Spark de NVIDIA, un equipo de escritorio con 128 GB de memoria pensado para correr modelos. No partí con dos candidatos. La noche anterior medí seis modelos ahí: Qwen3.8-27B, Qwen3.6-35B-A3B, Qwen3.8-Flash-Next, Nemotron 3.5 Lightning, GPT-OSS-120B y Gemma 4 26B. A todos les medí velocidad y estabilidad, y cuatro pasaron a una ronda corta de benchmarks de programación:

• Nemotron 3.5 Lightning quedó fuera: con carga de agente, el servidor se cayó 2 de 2 veces.
• Qwen3.8-Flash-Next fue el mejor en Terminal-Bench, pero ocupa 101 GB de los 128 y escribe código a unos 43 tokens por segundo, un tercio de lo que hace Qwen3.6. Sirve para trabajo largo y supervisado, no para el día a día.

Quedaron dos finalistas para el desempate: Qwen3.8-27B, que usa el modelo completo en cada paso, y Qwen3.6-35B-A3B, que activa solo una parte y por eso es más rápido.

No me quedé con los puntajes que publican otros. Corrí yo mismo dos benchmarks públicos conocidos, con los modelos sirviendo desde el Spark, y usé Harbor, una herramienta que corre cada tarea en un contenedor aislado y revisa el resultado con tests. Así la comparación con mi código es justa: mismo equipo, misma configuración, mismo modelo.

Benchmark (corrido en local)	Qwen3.8-27B	Qwen3.6-35B-A3B
Aider Polyglot (60 ejercicios)	42 %	50 %
Terminal-Bench 2.1 (20 tareas)	60 %	60 %

Con 60 ejercicios, la diferencia entre 42 % y 50 % cae dentro del margen de error. Empate técnico. Eso sí, Qwen3.6 hacía el doble de ejercicios por hora.

Con eso, cualquiera concluye que son modelos decentes que resuelven la mitad de lo que les pides. Yo también lo pensé.

¿Cómo medí la IA en mi propio código?

Es la misma idea con la que pruebo cada IA con tareas reales, llevada al código. Usé el mismo método que SWE-bench, pero con mis repos:

1. Tomé commits reales que ya estaban resueltos y que traían un test.
2. Volví el código al estado anterior a ese commit.
3. Le di al agente el enunciado del cambio, sin la solución.
4. El test que trajo el commit decide si lo resolvió.

Dos proyectos que uso en serio:

• Una startup en TypeScript: backend en NestJS (clases, servicios, inyección de dependencias) y frontend en Nuxt.
• Un sistema legacy en PHP 7.2 con Yii2 que sigue en producción.

Antes de usar cada tarea la validé dos veces: con la solución real tiene que pasar, y sin tocar nada tiene que fallar. Las que no cumplían quedaron fuera. De 30 tareas sobrevivieron 27: 14 en TypeScript y 13 en PHP.

Tiene sesgos que conviene saber: los dos repos tienen historia corta (semanas, no años), buena parte del código y de los tests los escribieron agentes, y 11 de las 15 tareas de PHP que preparé son del mismo módulo de correos.

Los modelos corrieron en local, en el Spark. Hubo dos excepciones que cuento más abajo: el juez que evaluó la calidad y un agente que se escapó a OpenAI.

¿Qué pasó? 22 % en código real

Proyecto	Resueltas (Qwen3.6 + Qwen Code)
Startup, TypeScript	3 de 14 (21 %)
Legacy, PHP + Yii2	3 de 13 (23 %)
Total	6 de 27 (22 %)

Del 50-60 % de los benchmarks al 22 %. Y el lenguaje casi no importó: TypeScript y PHP dieron lo mismo.

Mirando los intentos uno por uno, las fallas eran de dos tipos.

Casos borde. El modelo entendía la tarea y hacía el cambio principal bien, pero fallaba entre 1 y 4 chequeos del test: un correo que viene solo con espacios, un aviso que no incluía el estado, una lista que no debía modificarse. Los ejercicios de un benchmark rara vez llegan a ese nivel de detalle; los tests de un proyecto real cubren justo esos casos.

No terminar el trabajo. En una tarea el modelo hizo el diagnóstico correcto, escribió un plan y terminó con “¿Procedo?”. Nadie le iba a contestar: estaba corriendo solo. En otras tres repitió la misma acción una y otra vez hasta que el agente lo cortó.

Al 27B, el más lento de los dos, ni siquiera le alcanzó el tiempo: con 30 minutos por tarea no cerró 3 de las primeras 4. Le di 90, pero a ese ritmo la batería completa no iba a terminar en el día, así que la corté y pasé a una prueba más corta.

¿Cambia algo si cambio de agente?

Mi primera sospecha fue el agente. Qwen Code es solo uno; quizás otro sacaba más del mismo modelo. Armé una batería corta de 8 tareas (4 de cada proyecto), elegidas a propósito para separar agentes: 3 que Qwen Code había resuelto, 3 de casos borde y 2 donde se había trabado. Probé cinco agentes con Qwen3.6:

Agente (mismo modelo)	Resueltas de 8
Qwen Code	3
Codex CLI	3
Claude Code apuntado al modelo local	2
OpenCode	2
mini-swe-agent (solo terminal, sin nada más)	2

Todos entre 2 y 3. El agente más básico, que solo puede ejecutar comandos, quedó a una tarea del mejor. Cinco de las ocho tareas no las resolvió nadie, con ningún agente y con ninguno de los dos modelos.

Claude Code con un modelo local no rescata nada. El agente que me resuelve el trabajo diario, conectado a Qwen, rindió igual o peor que el agente propio de Qwen. Con el 27B resolvió las mismas 3 tareas que Qwen Code, pero tardando el doble. Lo que hace funcionar a Claude Code en mis proyectos es Opus 5.5, no solo el agente.

¿Pasar los tests significa que la tarea quedó lista?

Que un intento pase el test no dice cuánto trabajo te deja. Así que le pedí a Opus 5.5 que hiciera de juez: para cada intento comparó el enunciado, la solución real, el cambio del agente y la salida de los tests, y lo clasificó en cuatro categorías: listo para aceptar, casi (menos de 30 minutos de ajuste), rehacer o basura.

Modelo · agente	Pasan tests	Listo	Casi	Rehacer	Basura	Minutos de agente por tarea
Qwen3.8-27B · Qwen Code	3	3	3	1	1	47
Qwen3.6 · Qwen Code	3	1	4	3	0	6
Qwen3.6 · Codex	3	1	5	2	0	6

Los dos modelos resolvieron las mismas tareas, pero el 27B entregó tres listas para aceptar y Qwen3.6 una. A cambio, el 27B tardó ocho veces más.

Tarea por tarea se ve mejor. Cada color es lo que dijo el juez y ✓ marca las que pasaron los tests:

Modelo · agente	TS 1	TS 2	TS 3	TS 4	PHP 1	PHP 2	PHP 3	PHP 4
Tipo de tarea	resuelta antes	se trabó	resuelta antes	caso borde	resuelta antes	caso borde	caso borde	se trabó
Qwen3.8-27B · Qwen Code	🟢✓	🟡	🟢✓	🟠	🟢✓	🟡	🟡	🔴
Qwen3.8-27B · Claude Code	🟢✓	🟡	🟡✓	🔴	🟢✓	🟡	🟡	🔴
Qwen3.6 · Qwen Code	🟡✓	🟡	🟡✓	🟠	🟢✓	🟡	🟠	🟠
Qwen3.6 · Codex	🟡✓	🟡	🟡✓	🟠	🟢✓	🟡	🟡	🟠

🟢 listo · 🟡 casi · 🟠 rehacer · 🔴 basura. «Resuelta antes» son las que Qwen Code ya había resuelto en la batería completa.

Las cuatro filas casi se calcan: todas las combinaciones resuelven las mismas tres tareas y fallan las mismas cinco. Lo que cambia de una fila a otra es el color, o sea, cuánto trabajo te queda después.

En la batería completa de 27 tareas, Qwen3.6 dejó 2 listas y 16 para rehacer.

¿Entonces lo que escribí en mayo estaba mal?

En mayo conté que cambié el cerebro de mi agente de código de Opus a modelos open source. Hablaba de modelos open source en la nube, no locales, y en ese momento era cierto: el modelo chino me funcionaba mejor por lo que pagaba.

Lo que cambió, en mi uso diario, es la distancia con los modelos de punta: Claude Code con Opus 5.5 es lo que hoy me resuelve el trabajo en estos dos proyectos, y lo que corre en un equipo de escritorio no se le acerca. Espero que la próxima familia de modelos open weight vuelva a competir de verdad con ellos. Cuando salga, la mido igual, con estas mismas 27 tareas.

Lo que salió mal (y te puede pasar)

• Un agente mandó datos a OpenAI sin que se lo pidiera. Pi, otro de los agentes que quise probar, ignoró la variable que le decía a dónde conectarse y llamó a la API de OpenAI con una clave falsa. No hubo costo, pero el enunciado de cuatro tareas salió de mi red antes del rechazo. Si vas a darle código privado a un agente nuevo, primero haz una prueba con algo inocuo y confirma que el tráfico va a tu servidor.
• De los siete agentes que sumé a Qwen Code, tres no se pudieron medir. Los adaptadores de Hermes, Pi y OpenHands estaban rotos o desactualizados. Los agentes cambian más rápido que las herramientas que los evalúan.
• Ninguna combinación funcionó al enchufarla. Claude Code y Codex le piden al modelo un nivel de razonamiento que el 27B no acepta. Qwen Code pide 64.000 tokens de respuesta en cada llamada, y eso parecía un error de “contexto lleno” cuando no lo era. Cada combinación de modelo, agente y servidor necesita su propio ajuste.

¿Cuál es la mejor IA para programar, entonces?

Para mi código, hoy, Claude Code con Opus 5.5. Con un modelo local, ninguna combinación me sirve para delegar sin revisar. Con supervisión sí: Qwen Code con Qwen3.6 para cambios chicos que reviso de inmediato, o con el 27B si lo dejo trabajando en segundo plano y quiero algo más terminado.

Tu código no es el mío, así que mi respuesta te sirve de poco. Si vas a elegir modelo para programar, esto es lo que haría:

1. Saca 8 a 10 commits recientes que tengan test.
2. Vuelve cada uno al estado anterior y dale el enunciado al agente.
3. Antes de medir nada, confirma que el test pasa con la solución real y falla sin cambios.
4. Mira cuántas resuelve, y después cuánto te cuesta dejarlas listas.

Para comparar modelos en general, mi benchmark de modelos de IA te sirve para descartar candidatos antes de esa prueba.

Y si quieres conectar Claude Code a otro modelo para hacer tu propia prueba, aquí está la guía para usar Claude Code con cualquier LLM.