Si no puedes esperar y leer este post, simplemente copia/pega este prompt en tu claude code / codex / grok ahora mismo para obtenerlo de inmediato:
Instala XERJ (docs:
https://xerj.org/llms.txt ), indexa las fuentes de este proyecto y configura la codificación con referencia: clona e indexa los repositorios de código abierto más cercanos a lo que estamos construyendo, y busca cómo resolvieron un problema antes de escribir código.
la mayoría de la gente usa claude code como si fuera un pasante caro, y aquí te explico cómo hacerlo más inteligente en cada iteración (de verdad)
le das una tarea. hace algunas preguntas. revisa el repositorio, adivina cómo funciona tu código, escribe una implementación, algo se rompe. pegas el error. lo reescribe. algo más se rompe.
cada una de esas iteraciones son tokens que pagaste.
y claude generalmente no se queda atascado porque el problema sea difícil. Se queda atascado porque le hiciste redescubrir una respuesta que ya existe en algún lugar, ya sea en tu propio repositorio o en un proyecto de código abierto donde unos miles de desarrolladores ya encontraron los casos límite.
XERJ probó esto adecuadamente. 8 tareas de codificación, 4 idiomas, 16 ejecuciones por configuración, conteos de tokens extraídos directamente de claude -p.
desde la memoria: 260,916 tokens de salida desde una referencia: 9,982 tokens de salida
la memoria resolvió 11 de las 16. la referencia resolvió las 16.
así que concéntrate y lee esto de verdad ↓↓↓
el bucle por el que estás pagando
una sesión normal va así.
describes lo que quieres. claude explora. hace una suposición sobre tus patrones, tu manejo de errores, la forma de tus datos. escribe código basado en esa suposición. la suposición fue incorrecta en algún lado, así que algo se rompe, explicas el error, lo reescribe, y das vueltas hasta que el resultado coincide con lo que tenías en mente al principio.
la gente interpreta ese bucle como que claude es malo programando. Es todo lo contrario. Claude es muy bueno tomando un ejemplo funcional y adaptándolo a una nueva situación. El bucle ocurre cuando no hay ningún ejemplo presente, por lo que pasa la primera mitad de la sesión reconstruyendo uno.
los tokens de salida son los caros, con un precio alrededor de 5 veces superior al de entrada en los modelos claude. Así que cada vuelta de ese bucle se factura a la tarifa máxima.
un prompt y una referencia no son lo mismo
un prompt es una instrucción. una referencia es evidencia.
puedes escribir dos mil palabras describiendo exactamente cómo debería comportarse algo y claude aún tiene que traducir esa descripción a una implementación, y luego adivinar todo lo que omitiste.
una implementación funcional ya contiene las partes que nunca escribirías
la arquitectura, el manejo de errores, la lógica de reintento, el caso límite que alguien encontró en producción hace dos años, la razón por la que una función está dividida de la manera en que lo está
no mencionaste esas cosas en el prompt porque no sabías que importaban.
aquí está la versión más cruda de eso. un compilador eventualmente filtrará un nombre de método. Te dirá que la función se llama absorb y no push, y te cobrará de 20 a 25 veces los tokens para llegar allí. Un compilador nunca filtrará un contrato. Nada en tu cadena de herramientas te va a decir que esta estructura tiene que ser sellada antes de poder ser leída. Esa regla vive en la cabeza de quien escribió la librería y en el cuerpo de la función, y ninguna cantidad de escritura de prompts la recupera, porque no sabes que existe.
por eso esto reduce tokens y aumenta la calidad al mismo tiempo. Más contexto útil adentro, menos suposiciones, menos reintentos.
lo que mostraron las pruebas
frente a la configuración basada en grep, la codificación con referencia usó 2.7 veces menos tokens de salida en las mismas 8 tareas. El costo total entre las ramas fue de $11.18 desde la memoria, $3.27 con grep, $1.58 con una referencia.
grep parece la solución y en su mayoría no lo es. Grep le dice al agente dónde buscar, y luego el agente aún tiene que leer el archivo en el contexto para entenderlo. Un corpus en este estudio extrajo 1.06 millones de tokens de entrada haciendo exactamente eso. Tokens más baratos, una enorme cantidad de ellos, más cada iteración del agente que soportaste.
luego está la ejecución más grande. 13 librerías escritas desde cero para el estudio en 5 idiomas, cada una compilando y pasando sus propias pruebas, cada una llevando una regla de tiempo de ejecución que el compilador no puede advertirte. Construidas así a propósito, porque no puedes probar la recuperación en código que el modelo ya memorizó.
solo, desde la memoria: 1 de 21 con recuperación: 21 de 21
$21.90 contra $3.38.
ese es un resultado diferente, no uno más barato.
el ejemplo más claro allí es una tarea de Java. Construir un libro mayor de solo anexar, sellar antes de reproducir, truncar a un punto de control. Desde la memoria reinventó todo, 503 líneas, aproximadamente 36,000 tokens, semántica de truncamiento incorrecta, falló la prueba. Con la referencia escribió cuatro líneas. 103 tokens. Pasó.
la distribución por idioma te dice dónde está el valor. Python de 14,752 a 214. C de 18,792 a 988. Java de 27,108 a 98. JavaScript solo fue de 4,300 a 646, porque un trie de prefijos es una estructura conocida y el modelo ya sabía la mitad de la respuesta.
los desarrolladores que usan XERJ en el trabajo diario normal reportan aproximadamente 5 veces menos tokens. Eso es auto-reportado en lugar de comparado, así que tómalo como el piso y no el titular.
por qué un prompt más largo no soluciona esto
durante un tiempo, la respuesta a una mala salida siempre fue la misma. Escribe un mejor prompt. Añade más contexto. Explica la arquitectura.
y a veces funciona.
pero un prompt es tú describiendo una solución que aún no has escrito. Una referencia es una solución que alguien ya envió y depuró. No puedes describir tu camino hacia la lógica de reintento que solo existe porque un mantenedor fue limitado por tasa a las 3 a.m. y lo parcheó apresuradamente.
el código ya está ahí. No tienes que explicar las decisiones que lo llevaron a ser así.
encontrar la referencia es el trabajo real
aquí es donde se desmorona.
hacerlo manualmente significa abrir github, leer repositorios que coinciden a medias, buscar en solicitudes de extracción antiguas, luego abrir tu propio código de hace ocho meses e intentar recordar cómo llamaste al archivo. Para cuando hayas encontrado algo utilizable, podrías haber escrito la funcionalidad.
así que la búsqueda tiene que ser barata, o nadie lo hace dos veces.
para eso sirve XERJ. Indexa código y te permite buscar por el problema que estás resolviendo en lugar de por nombre de archivo o palabra clave, luego extrae la implementación coincidente como una referencia que puedes pasar directamente a claude. https://xerj.org
cómo ejecutarlo
1) copia/pega el prompt de instalación en la sesión de claude code
Instala XERJ (docs:
https://xerj.org/llms.txt ), indexa las fuentes de este proyecto y configura la codificación con referencia: clona e indexa los repositorios de código abierto más cercanos a lo que estamos construyendo, y busca cómo resolvieron un problema antes de escribir código.
2) verifica la respuesta de tu agente de codificación y sugiere proyectos para clonar como referencias
sea lo que sea que estés construyendo, siempre sabes quién más está haciendo lo mismo. Algunos proyectos ya serán encontrados por claude code en esta etapa, y puedes añadir más por tu cuenta. 5-10 suele ser suficiente, pero depende de lo que estés programando
3) crea la próxima funcionalidad del producto y verifica los resultados
solo déjalo fluir y disfruta (o no) los nuevos resultados. Siempre puedes volver a la codificación que desperdicia tokens, pero estoy seguro de que verás la diferencia de inmediato
4) mantenlo funcionando y ayuda a la comunidad con tus comentarios
cada tarea que terminas de esta manera se convierte en la referencia para la siguiente. La biblioteca se acumula. En cualquier momento en que
cuando omitirlo
si el modelo ya conoce el código, esto es un impuesto y nada más. Sin embargo, no es un caso frecuente.
también midieron eso, en valkey y memcached, código público real en el que claude definitivamente ha sido entrenado. Desde la memoria obtuvo 6 de 6 por $1.49. La recuperación obtuvo 5 de 6 por $4.40. Quedó último y costó tres veces más que no hacer nada.
así que la línea está en el código privado, propietario o genuinamente desconocido por un lado, y todo lo que el modelo ya ha consumido por el otro.
si lo que estás construyendo nunca se ha construido antes, no hay nada a lo que señalar y vuelves a tener que describirlo.
si la referencia está escrita contra una versión del framework que no estás usando, cuesta más de lo que ahorra.
y si la tarea tiene cuatro líneas, simplemente escríbela.
lo que aún está abierto
las 13 librerías fueron construidas para el estudio, lo que las hace desconocidas por construcción y también las hace pequeñas. Nadie ha ejecutado esto contra un código base privado genuinamente grande todavía. La expectativa es que la brecha se amplíe allí, ya que el costo de grep aumenta con el tamaño del árbol mientras que la recuperación se mantiene estable, pero eso es una suposición hasta que alguien lo mida.
todos los números anteriores provienen del benchmark publicado por XERJ, con datos brutos por ejecución en su repositorio. https://xerj.org/case-studies/reference-coding
la conclusión
no necesitas un modelo diferente y no necesitas dejar claude code.
necesitas dejar de empezar cada tarea desde cero, porque lo que estás construyendo probablemente ya existe en algún lugar de tu repositorio o en un proyecto de código abierto que lo resolvió hace dos años.
si alguien ya lo resolvió, pásale a claude su código y deja que trabaje a partir de eso. Y no te cuesta nada, solo un prompt
