Si no puedes esperar y leer esta publicación, solo copia y pega este prompt en tu claude code / codex / grok ahora mismo para obtenerlo de inmediato:
Instala XERJ (documentación:
https://xerj.org/llms.txt ), indexa las fuentes de este proyecto y configura la codificación con referencias: 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 interacció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 interacciones 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 lado, 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 correctamente. 8 tareas de codificación, 4 lenguajes, 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 es 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, le 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 para codificar. 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 aproximadamente 5 veces mayor que los 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 en 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 cierta manera
no mencionaste eso en el prompt porque no sabías que era importante.
aquí está la versión más clara 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 debe sellarse antes de poder leerse. esa regla vive en la cabeza de quien escribió la biblioteca 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 mejora 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 referencias usó 2.7 veces menos tokens de salida en las mismas 8 tareas. el costo total entre las variantes fue de $11.18 desde la memoria, $3.27 con grep, $1.58 con una referencia.
grep parece la solución y generalmente no lo es. grep le dice al agente dónde mirar, pero 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 interacción del agente que tuviste que esperar.
luego está la ejecución más grande. 13 bibliotecas escritas desde cero para el estudio en 5 lenguajes, cada una compilando y pasando sus propias pruebas, cada una llevando una regla 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.
eso es un resultado diferente, no uno más barato.
el ejemplo más limpio 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. al darle la referencia escribió cuatro líneas. 103 tokens. pasó.
la distribución por lenguaje 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 pasó 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 reportan aproximadamente 5 veces menos tokens. ese dato es auto-reportado en lugar de comparado, así que tómalo como el mínimo y no el titular.
por qué un prompt más largo no soluciona esto
durante un tiempo, la respuesta a la mala salida siempre fue la misma. escribe un mejor prompt. agrega 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 lanzó 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 eso.
encontrar la referencia es el verdadero trabajo
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 encuentres algo utilizable, ya 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 (documentación:
https://xerj.org/llms.txt ), indexa las fuentes de este proyecto y configura la codificación con referencias: 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 agregar más según tu elección. 5-10 suele ser suficiente, pero depende de lo que estés codificando.
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 ineficiente, 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 termines de esta manera se convierte en la referencia para la siguiente. la biblioteca se acumula. en cualquier momento en que
cuándo 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 es 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 apuntar y vuelves a 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, solo escríbela.
lo que aún está abierto
las 13 bibliotecas se construyeron para el estudio, lo que las hace desconocidas por construcción y también 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, 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 costó nada, solo un prompt
