Claude Code + Graphify: 70 veces menos tokens en tu código

Tu IA está programando a ciegas (y así lo arreglas)

Si trabajas con Claude Code, Cursor o Copilot en un proyecto medianamente grande, malas noticias: tu IA está programando a ciegas. No porque sea tonta, sino porque lee tus archivos uno a uno, sueltos, sin entender de verdad cómo encajan entre ellos. Es como darle a alguien las piezas de un puzzle pero esconderle la foto de la caja.

Un proyecto real no es una lista de archivos: es una red de relaciones. Un archivo importa a otro, una función llama a otra, y un cambio en uno te revienta algo en otro. Esa “foto” la tienes tú en la cabeza, pero la IA no. Por eso a veces toca el archivo equivocado, duplica lógica que ya existía o rompe un flujo que ni se paró a mirar.

Hoy te enseño a darle esa foto completa: un mapa de todo tu proyecto que la IA consulta de un vistazo en vez de ir archivo por archivo. Se monta con un comando, es gratis, open source, el código no sale de tu máquina y usa hasta 71,5 veces menos tokens por consulta. Más barato, más rápido y, sobre todo, la IA deja de perderse.

Qué es Graphify

Graphify es una skill open source para asistentes de IA (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Hermes…) que convierte un proyecto entero en un grafo de conocimiento consultable. Pasas de tener archivos sueltos a tener conocimiento conectado.

Lo importante: el análisis del código se hace 100% en local (con árboles de sintaxis tree-sitter), así que el contenido de tu código no sale de tu máquina. Solo se usa un modelo externo para la parte de “etiquetado semántico” del grafo, y eso cuesta céntimos (ahora lo vemos).

El concepto de grafo: de lista a red

Para entenderlo hay que entender qué es un grafo:

• Nodos = las piezas (archivos, clases, funciones).
• Aristas = cómo se relacionan esas piezas (un import, una llamada, una dependencia).

Una lista te dice todo lo que existe; un grafo te dice cómo se conecta. Graphify además agrupa los nodos en comunidades (zonas de colores) por densidad de conexiones, no por carpetas: agrupa por concepto. En un proyecto real verás comunidades tipo admin dashboard, branding, backend server, invoice templates… cada una interconectada con las demás.

Cómo construye Graphify el mapa (3 pasos)

1. Lee la estructura del código (clases, funciones, imports y llamadas) mediante análisis local con tree-sitter. Soporta una veintena de lenguajes: Python, JS/TS, Go, Rust, Java, C/C++, Ruby, C#, Kotlin, PHP, Swift y más.
2. Analiza el contenido multimedia del proyecto (vídeos, audios, transcripciones).
3. Recoge los documentos e imágenes (PDFs, diagramas, notas de contexto).

Después fusiona todo en un único grafo y agrupa las zonas por densidad de conexiones (técnicamente, con NetworkX y clustering de Leiden). El resultado es ese mapa de comunidades interconectadas.

Los 3 documentos que genera

Al aplicar la skill obtienes (al menos) tres archivos:

• graph.html — la interfaz visual interactiva: el mapa donde haces clic, activas/desactivas comunidades y ves las conexiones. Práctico para ti.
• graph_report — un resumen con los nodos clave, conexiones e información condensada. Útil para ti y para la IA.
• graph.json — aquí está toda la información condensada. Es enorme (en el ejemplo, más de 30.000 líneas) y totalmente consultable. La IA busca muchísimo mejor en este tipo de archivos estructurados.

Por qué ahorra hasta 70× tokens

Hasta ahora tu IA buscaba de dos formas:

• GREP (coincidencia de texto): si no sabes cómo se llama algo exactamente, falla.
• Semántica (por significado): encuentra conceptos, pero no ve las dependencias reales.

Con Graphify añades una tercera: búsqueda por grafo, que recorre relaciones, sigue dependencias y analiza impacto. En vez de leer 30 archivos en bruto para entender una zona, la IA consulta el resumen y el grafo. De ahí el dato del benchmark: ~71,5 veces menos tokens por consulta. Más barato, más rápido y la IA se pierde menos.

Para qué sirve: 6 casos de uso

1. Onboarding rápido: entregas el grafo a otra IA y tiene una radiografía instantánea del proyecto.
2. ★ Análisis de impacto: “quiero añadir X, Y y Z; analiza si algo de eso rompería mi proyecto”. Uno de los usos más potentes.
3. Refactors seguros: primero mapea, luego planifica, después toca el código (ideal combinado con un arnés/guardarraíl que ate en corto a la IA).
4. Documentación viva: el grafo crece; vas pidiéndole que añada información y se teje una telaraña de conceptos conectados.
5. Complejidad oculta: detecta acoplamiento y piezas demasiado centrales.
6. ★ Preguntar al proyecto: “¿cómo funciona el login?” → la IA va al resumen en lugar de leer archivo por archivo.

Dónde aporta valor (y dónde no)

Graphify brilla en proyectos grandes y conectados: tu propio SaaS, un CRM, una app con usuarios y pagos, un backend con muchas integraciones o cualquier proyecto que trabajas durante meses.

Aporta poco en tareas simples: scripts sueltos, un único archivo o proyectos pequeños de una funcionalidad muy concreta, donde no hay muchos conceptos que conectar.

Instalación paso a paso (en Claude Code)

Lo bonito es que no instalas nada a mano: dejas que la IA lo haga.

1. Abre el repositorio de Graphify

Ve a github.com/safishamsi/graphify. El README explica todo y con qué herramientas se conecta (Claude Code, Cursor, Gemini CLI, OpenCode, Hermes…). Puedes leerlo en español si lo necesitas.

2. Requisitos

• Un asistente que soporte skills: Claude Code (o Cursor, Codex, Gemini CLI…).
• Python disponible (la skill arrastra dependencias como tiktoken).
• Una API key de un LLM (Gemini u OpenAI) para el paso de extracción semántica. El análisis del código es local; el etiquetado de comunidades necesita un modelo.

3. Pídele a Claude que lo instale (de forma aislada)

Abre Claude Code en tu proyecto, ponlo en auto mode y pégale un prompt como este:

Quiero probar Graphify en una copia aislada de este proyecto.
Objetivo: instalar Graphify de forma aislada (sin tocar mi código de
producción), generar el grafo completo del proyecto y dejarme los archivos
graph.html, graph_report y graph.json. Repo: https://github.com/safishamsi/graphify
Si necesitas una API key para la extracción semántica, dímelo y te indico
cuál usar de mi .env.

Claude clona/instala la skill, resuelve dependencias y empieza a construir el grafo.

4. Configura la API para la extracción semántica

En cierto punto, la IA te avisará de que algunos archivos requieren extracción semántica con un LLM. Te dará a elegir entre hacerlo solo con código (sin LLM) o usar una API. Dile que use tu key (por ejemplo, una API de Gemini que tengas en el .env). Coste real del ejemplo del vídeo: 3 céntimos para generar el grafo completo (1.094 nodos, 1.927 aristas, 81 comunidades).

Si las comunidades salen sin nombre (tipo community 1, 2, 3…) es que no consiguió etiquetarlas. Pídeselo: “reintenta el etiquetado de comunidades”. En el vídeo, Gemini 3 Flash falló y al reintentar con 2.5 Pro funcionó. Si te pasa, prueba con otro modelo.

5. Abre el grafo

Pídele a la IA el graph.html y ábrelo en el navegador: tendrás el mapa interactivo para activar/desactivar comunidades y explorar conexiones.

La regla de oro: mapea antes de tocar

El error es dejar que la IA empiece a editar a lo loco. La forma correcta de trabajar con el grafo:

Mapear → entender → analizar impacto → planificar → y solo entonces tocar el código.

Díselo explícitamente: “No empieces tocando el código. Primero usa el grafo para entender cómo funciona este proyecto, mide el impacto de lo que vas a hacer y luego planifícalo.” Consejo extra: añade esa instrucción a tu CLAUDE.md (o system prompt) para que lo haga siempre, sin recordárselo cada vez.

Ejemplo real: “¿qué se rompería si modifico X?”

En el vídeo, sobre un programa de facturación, la consulta es: “¿qué se rompería si modifico el registro de alta de factura?”. Con el grafo conectado, la IA:

1. Localiza el nodo real de “alta de factura” en el grafo.
2. Traza el impacto de más directo a más lejano.
3. En paralelo, busca los tests existentes que tocan facturas.

En ~1 min 48 s devuelve un análisis combinando grafo + código real: la creación de factura ocurre dentro de una transacción (idempotencia por cliente, reserva de número de serie, cálculo de impuestos, insert…), y advierte qué se rompería: tocar la firma/valor de retorno rompe el endpoint; cambiar el esquema de entrada puede romper API y frontend a la vez; alterar las columnas del insert afecta al esquema de base de datos. Con enlaces para abrir cada archivo afectado.

¿El coste? Unos 5.500 tokens. Una ridiculez para el valor que aporta. La instalación completa consumió alrededor del 5% del contexto. La misma consulta sin el grafo habría sido muchísimo más cara.

Mantén el grafo vivo

El grafo es una foto del proyecto en un momento dado. Si haces cambios grandes (mueves módulos, añades features), vuelve a regenerarlo para que la IA trabaje con la realidad actual. Es el mismo comando, y vuelve a costar céntimos. Esa es la idea de la “documentación viva”: el mapa se actualiza contigo.

Conclusión

Graphify le da a tu IA lo que le faltaba: la foto de la caja del puzzle. En lugar de leer archivos sueltos y gastar tokens a lo bestia, consulta un mapa de relaciones, sigue dependencias y te dice qué se va a romper antes de tocar una línea. Más barato, más rápido y mucho menos errores.

En ExpertBrain montamos este tipo de infraestructura de agentes y flujos de IA para empresas y organismos en producción. Si quieres llevar tu desarrollo asistido por IA al siguiente nivel, hablemos.