Graphify vs CodeGraph: testei os dois com Claude Code

Autoria: The Gray Cat · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Graphify vs CodeGraph: I Tested Both With Claude Code · Canal: The Gray Cat · 09:16 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Claude Code, Engenharia de software com IA, Inferência e otimização de modelos

Resumo

O vídeo compara Claude sem ferramentas de grafo, Graphify e CodeGraph na implementação de uma exportação de legendas SRT palavra por palavra para o The Gray Cut. CodeGraph concluiu a tarefa mais rápido, usou menos tokens e foi a única opção aprovada em duas verificações adicionais de timing. Graphify também reduziu o uso de tokens, mas exigiu uma indexação inicial mais demorada e apresentou erros de timing no teste extremo. O criador ressalta que foi apenas uma execução por configuração, portanto os resultados não provam um vencedor geral.

Pontos-chave

A tarefa era exportar um arquivo SRT com uma legenda por palavra, respeitando as alterações feitas na edição.
Claude sem ferramentas de grafo encontrou a arquitetura correta, passou nos testes existentes e produziu uma implementação funcional.
O primeiro índice do Graphify levou cerca de três minutos e custou aproximadamente US$ 2,30 no total, incluindo o uso de Gemini e Claude.
CodeGraph criou seu índice local em menos de dois segundos, sem usar tokens de modelo, e pode atualizá-lo automaticamente enquanto o servidor está ativo.
Na execução, CodeGraph terminou em 8 minutos e 45 segundos, contra 9 minutos e 42 segundos para Claude sem ferramentas e 9 minutos e 15 segundos para Graphify.
CodeGraph usou 4,23 milhões de tokens, 35% menos que a configuração de referência; Graphify usou 5,34 milhões.
As três implementações passaram nos testes próprios e pareceram corretas no aplicativo, mas verificações adicionais revelaram erros de timing no Graphify e, em menor grau, na versão sem ferramentas.
O teste teve apenas uma execução por configuração, e o criador recomenda tratar os resultados como evidência concreta daquela tarefa, não como uma conclusão universal.

Capítulos

Início	Capítulo	Resumo
00:00	A tarefa e a configuração do teste	O criador apresenta Graphify e CodeGraph e define a exportação de um SRT palavra por palavra como tarefa de comparação.
02:02	Claude sem ferramentas e Graphify	A versão de referência funciona, enquanto o Graphify exige configuração adicional e oferece resultados de consulta que pouco ajudam no planejamento.
04:07	Configuração e teste do CodeGraph	O CodeGraph cria um índice local rapidamente, integra-se ao Claude Code e fornece informações úteis para a tarefa.
06:09	Tempo, tokens e qualidade do código	O vídeo compara duração e uso de tokens e revela diferenças de precisão de timing nas três implementações.
08:15	Limitações e conclusão	O criador ressalta o tamanho reduzido da amostra, recomenda experimentar o CodeGraph primeiro e propõe uma comparação maior.

Citações

Você vai ver qual deles economizou tokens e se o código continuou correto. — 00:30

Mesmo assim, o planejamento pareceu muito mais rápido do que com Claude sem ferramentas. — 05:09

Nesta execução, o CodeGraph vence. — 07:43

Uma execução por configuração não pode provar quem vence em geral. — 08:15

Conceitos e entidades

Graphify (ferramenta): Ferramenta que analisa a estrutura de um projeto e cria um grafo consultável, além de um mapa visual.
CodeGraph (ferramenta): Ferramenta que indexa código em um banco de dados SQLite local e oferece exploração do grafo por meio de MCP.
Claude Code (ferramenta): Ambiente usado para executar as tarefas e integrar as ferramentas de grafo ao trabalho de Claude.
Claude Opus 5 (modelo): Modelo usado nos testes, com esforço médio e modo de planejamento.
Gemini 3 Flash Preview (modelo): Modelo usado pelo Graphify para processar documentos e imagens e extrair conceitos e conexões.
Codex (ferramenta): Ferramenta usada para auditar os exportadores com um teste de linha do tempo extremo.
MCP (conceito): Protocolo pelo qual o CodeGraph disponibiliza a Claude a ferramenta codegraph explore.
The Gray Cut (repo): Projeto de edição de vídeo usado para comparar as três abordagens de implementação.
SRT (conceito): Formato de arquivo de legendas usado na funcionalidade de exportação testada.

Tradução completa (pt-BR)

00:00 Meus vídeos recentes de comparação foram muito bem, e os comentários encheram minha lista de testes de novo. Graphify e CodeGraph se destacaram nos comentários. Ambos conseguem criar um mapa consultável do seu projeto antes do trabalho em um recurso. Claude pode pesquisar esse mapa em vez de abrir cada arquivo. Eu nunca tinha usado nenhum dos dois, então criei um recurso do The Gray Cut usando apenas Claude e depois repeti o processo com cada ferramenta. Uma produziu um enorme mapa visual; a outra terminou de criar o índice quase imediatamente. No final,

00:30 você vai ver qual economizou tokens e se o código continuou correto. O recurso era bem pequeno. Eu queria que o The Gray Cut exportasse um arquivo SRT palavra por palavra. Cada palavra mantida se torna uma legenda. O tempo armazenado nela é ajustado à edição atual. Usei esse arquivo para marcar os capítulos. Ele também me ajudou a sincronizar os motion graphics com o roteiro. Essa sincronização

01:00 é um pouco imprecisa. Ainda assim, economiza bastante tempo de edição. O The Gray Cut já armazena cada palavra reconhecida, então o exportador precisava reutilizar esses dados. Também precisava acompanhar a edição atual. As falas excluídas desaparecem, enquanto os clipes inseridos deslocam tudo o que vem depois deles. Vou deixar o prompt completo na tela. Cada execução começou a partir de um commit congelado e recebeu o mesmo prompt para o recurso. Usei Claude Opus 5 com esforço médio no modo de planejamento. Claude sem ferramentas extras foi o primeiro

01:31 como referência. Claude sem ferramentas extras começou com suas ferramentas de pesquisa habituais. Primeiro, inspecionou os exportadores e os modelos de dados existentes; depois, rastreou a lógica de edição no servidor. Em seguida, encontrou o botão de exportação e o código da linha do tempo em Swift. Todos os 16 testes específicos passaram. O script de regressão terminou sem erros, e o app Swift foi compilado. Depois, abri o app e exportei o SRT de palavras. À primeira vista, o arquivo parecia exatamente como eu esperava. Cada palavra tinha sua própria legenda.

02:02 Claude sem ferramentas extras encontrou a arquitetura certa e produziu um recurso utilizável. Agora, as ferramentas de grafos precisavam economizar tempo suficiente de investigação para justificar seus índices. Graphify foi a próxima. Primeiro, instalei um pacote Python chamado graphifyy. Sim, com dois Ys. Depois, executei Graphify dentro do projeto. Ele detectou 219 arquivos e começou a criar o grafo. Graphify analisa o código localmente e registra sua estrutura. Essa parte não precisa de um modelo de IA. Documentos e imagens

02:34 funcionam de outra forma. Graphify usa um modelo para transformar o conteúdo deles em conceitos e conexões. Eu já tinha uma chave do Gemini disponível, então ele selecionou Gemini 3 Flash Preview para esses arquivos. Não era um modelo de embedding. Gemini usou cerca de 230.000 tokens, o equivalente a aproximadamente 14 centavos pelas tarifas pagas padrão. Claude também participou porque iniciei o workflow dentro do Claude Code. Claude executou os comandos e cuidou da configuração. Gemini processou os arquivos que não eram de código.

03:05 A primeira análise dos documentos falhou. A integração do Gemini no Graphify estava sem uma dependência do Python. Claude instalou os extras do Graphify para Gemini e tentou de novo. O comando completo de indexação levou cerca de três minutos. Graphify armazenou os dados reutilizáveis e um mapa visual em HTML dentro de graphify-out. Treze arquivos que não eram de código ainda não produziram nenhuma entrada no grafo. Mesmo assim, o mapa final ficou bem impressionante. Então, iniciei a execução do recurso e vi Claude usando grep e lendo arquivos normalmente.

03:36 Interrompi a execução porque Graphify não parecia estar ativo. Acontece que eu não tinha percebido que havia um comando separado, graphify claude install. Executei-o e reiniciei Claude. Então, comecei a execução medida. Durante o planejamento, Claude consultou Graphify três vezes e disse que ele quase não ajudou. Uma consulta retornou dados, em sua maioria, irrelevantes. Outra não encontrou nenhum nó SRT. Claude ainda recorreu à pesquisa normal, embora o arquivo exportado parecesse correto no app. Se esses testes forem

04:07 úteis, inscreva-se. Se você usa Graphify, entre no Discord do Gray Cat e me conte o que deixei passar. Por fim, passei para CodeGraph versão 1.6.0. Instalei sua ferramenta de linha de comando e depois a configurei para Claude Code e Codex neste projeto. Dentro da worktree, executei codegraph init. A gravação do índice em si terminou em menos de dois segundos. Foi rápido a ponto de parecer suspeito. CodeGraph armazena um banco de dados SQLite local dentro da pasta .codegraph do projeto.

04:38 Ele registra onde o código está definido e como as partes se conectam. A criação do índice não usou tokens de modelo. Enquanto o servidor está em execução, CodeGraph monitora os arquivos alterados e atualiza o índice em segundo plano. O instalador adicionou instruções do projeto para os dois agents. Codex recebeu AGENTS.md, enquanto Claude recebeu .claude/CLAUDE.md. Também tentei codegraph ui, mas CodeGraph 1.6.0 não incluía esse comando. CodeGraph também funciona como servidor MCP.

05:09 Ele oferece a Claude uma ferramenta chamada codegraph explore, e as instruções adicionadas dizem a Claude para recorrer a essa ferramenta antes de usar grep ou ler arquivos. Também habilitei a opção que adiciona informações do grafo ao prompt de Claude. Durante o planejamento, Claude chamou CodeGraph duas vezes. Os resultados continham ruído, mas retornaram o código-fonte atual e o fluxo de exportação relevante. Claude ainda usou algumas ferramentas normais para obter detalhes que faltavam. Mesmo assim, o planejamento pareceu muito mais rápido do que com Claude sem ferramentas extras. O SRT exportado

05:39 parecia igual aos outros dois. Nesse ponto, as três versões funcionavam no app. Eu ainda não tinha verificado o tempo exato. Certo, vamos aos resultados. Primeiro, o tempo. Claude sem ferramentas extras levou nove minutos e 42 segundos. Graphify terminou em 9:15. CodeGraph chegou primeiro, em oito minutos e 45 segundos. Graphify parece próximo até eu incluir a primeira criação do índice. O índice elevou o total para 12 minutos e 44 segundos. O índice de CodeGraph acrescentou menos de dois segundos,

06:09 então o total ficou em cerca de 8:47. Sua fase de planejamento também foi 40% mais rápida do que a de Claude sem ferramentas extras. Claude sem ferramentas extras e Graphify precisaram de 28 chamadas de navegação durante o planejamento. CodeGraph precisou de 17. Agora, os tokens. Claude sem ferramentas extras usou 6,55 milhões, enquanto Graphify reduziu esse número para 5,34 milhões. CodeGraph usou 4,23 milhões, 35% abaixo da referência. Graphify reduziu o custo equivalente pela API

06:41 de US$ 5,16 para US$ 4,29. CodeGraph baixou ainda mais, para US$ 3,71. Fiz esses testes usando minha assinatura, então não paguei esses valores diretamente. Graphify também teve sua sessão de indexação separada. Gemini custou cerca de 14 centavos. Claude usou outros US$ 2,15 para conduzir o workflow. Juntos, o primeiro índice do Graphify custou cerca de US$ 2,30 antes do trabalho no recurso. Normalmente, você cria o índice completo uma vez,

07:11 e ele fica armazenado no disco. À medida que o código muda, você ainda precisa atualizar o índice de vez em quando. As atualizações do código são locais. CodeGraph é mais conveniente nesse caso, porque seu servidor em execução atualiza o índice automaticamente. Documentos e imagens alterados podem usar Gemini novamente. E agora, a qualidade do código. As três versões passaram nos próprios testes e pareciam corretas no app. Depois de concluir as três execuções, pedi a Codex para auditar todos os exportadores com uma linha do tempo extrema de 100 clipes de um frame. Graphify terminou um frame antes,

07:43 o que equivale a 33 milissegundos a 30 frames por segundo. Um frame parece pouco e o teste foi extremo, mas o erro aumentava a cada clipe. Outro bug poderia descartar uma palavra válida perto de um corte. Claude sem ferramentas extras teve um erro de arredondamento menor, de um milissegundo. CodeGraph passou nas duas verificações de tempo. Então, nesta execução, CodeGraph vence. Usou menos tokens e terminou mais rápido. Também foi a única implementação que passou nas duas verificações de tempo adicionais. Agora, sobre o tamanho da amostra.

08:15 Uma pessoa que assistiu disse que uma execução nunca é suficiente e pediu uma tarefa maior. Outra queria testes predefinidos. E, sim, este teste ainda tem o mesmo problema de tamanho da amostra. Uma execução por configuração não prova que existe um vencedor geral. Mais execuções tornariam o resultado mais confiável. Faço esses experimentos à noite e pago usando minhas assinaturas normais. Não tenho patrocínio da Anthropic nem da OpenAI. Meus limites de tokens são muito, muito reais. Claude Code e os modelos continuam mudando.

08:45 As ferramentas de grafos avançam na mesma velocidade, então um benchmark maior ainda pode ficar desatualizado em poucas semanas. Mesmo assim, estes números mostram o que aconteceu aqui. Eles dão a você algo concreto para testar. Meu principal objetivo é explicar como essas ferramentas funcionam. Assim, você pode decidir se alguma delas serve para o seu projeto. Com base nesta execução, eu testaria CodeGraph primeiro. Se este vídeo alcançar 100 curtidas em uma semana, vou testar um recurso maior. Vou adicionar Graft e GitNexus, fazendo uma comparação entre quatro ferramentas.

09:16 Enquanto isso, conte qual delas você usaria, Graphify ou CodeGraph, e por quê. Se quiser outra comparação para economizar tokens, assista a Caveman vs Ponytail vs RTK em seguida. São mais nove minutos de mim encarando o terminal, com meu gato atrás da cadeira na pose de armadilha de barriga.

Transcrição original

[00:00] My recent comparison videos did pretty well, and the comments filled my testing list again. Graphify and CodeGraph stood out in the comments. Both can build a queryable map of your project before feature work. Claude can search that map instead of opening every file. I had never used either, so I built one Gray Cut feature with plain Claude, then repeated it with each tool. One produced a giant visual map, the other finished its index almost immediately. By the end,

[00:30] you’ll see which one saved tokens and whether the code stayed correct. The feature was pretty small. I wanted The Gray Cut to export a word-by-word SRT file. Each retained word becomes one subtitle cue. Its stored timing gets adjusted to the current edit. I used this file for chapter timestamps. It also helped me line up motion graphics with the script. That synchronization

[01:00] is a bit imprecise. It still saves a lot of editing time. The Gray Cut already stores every recognized word, so the exporter had to reuse that data. It also had to follow the current edit. Deleted speech disappears, while inserted clips move everything after them. I’ll leave the full prompt on the screen. Every run started from one frozen commit and received the same feature prompt. I used Claude Opus 5 at medium effort in plan mode. Plain Claude went first

[01:31] as the baseline. Plain Claude started with its usual search tools. It inspected the existing exporters and data models first, then traced the edit logic through the server. After that, it found the Swift export button and timeline code. All 16 focused tests passed. The regression script finished green, and the Swift app built. Then I opened the app and exported the word SRT. At first glance, the file looked exactly like I expected. Every word had its own cue.

[02:02] Plain Claude found the right architecture and produced a usable feature. Now the graph tools had to save enough investigation to justify their indexes. Graphify went next. First, I installed a Python package called graphifyy. Yes, two Ys. Then I ran Graphify inside the project. It detected 219 files and started building the graph. Graphify scans the code locally and records its structure. That part does not need an AI model. Documents and images

[02:34] work differently. Graphify uses a model to turn their contents into concepts and connections. I already had a Gemini key available, so it selected Gemini 3 Flash Preview for those files. This was not an embedding model. Gemini used around 230,000 tokens, worth about 14 cents at standard paid rates. Claude was also involved because I launched the workflow inside Claude Code. Claude ran the commands and dealt with setup. Gemini processed the non-code files.

[03:05] The first document scan failed. Graphify’s Gemini integration was missing one Python dependency. Claude installed Graphify’s Gemini extras and tried again. The complete indexing command took around three minutes. Graphify stored the reusable data and an HTML visual map inside graphify-out. Thirteen non-code files still produced no graph entries. The finished map looked pretty impressive anyway. Then I started the feature run and saw Claude using grep and normal file reads.

[03:36] I stopped the run because Graphify did not appear to be active. Turns out I had missed a separate graphify claude install command. I ran it and restarted Claude. Then I began the measured run. During planning, Claude queried Graphify three times and said it barely helped. One query returned mostly unrelated data. Another found no SRT node at all. Claude still relied on normal search, although the exported file looked correct in the app. If these tests are

[04:07] useful, subscribe. If you use Graphify, join the Gray Cat Discord and tell me what I missed. Finally, I moved to CodeGraph version 1.6.0. I installed its command-line tool, then configured it for Claude Code and Codex in this project. Inside the worktree, I ran codegraph init. The actual index write finished in under two seconds. That was almost suspiciously fast. CodeGraph stores a local SQLite database inside the project’s .codegraph folder.

[04:38] It records where code is defined and how the pieces connect. Building its index used no model tokens. While its server is running, CodeGraph watches changed files and updates the index in the background. The installer added project instructions for both agents. Codex got AGENTS.md, while Claude got .claude/CLAUDE.md. I tried codegraph ui too, but CodeGraph 1.6.0 did not include that command. CodeGraph also runs as an MCP server.

[05:09] It gives Claude one tool called codegraph explore, and the added instructions tell Claude to reach for that tool before grep or reading files. I also enabled the option that adds graph information to Claude’s prompt. During planning, Claude called CodeGraph twice. The results contained noise, but they returned current source and the relevant export flow. Claude still used a few normal tools for missing details. Even so, planning felt much faster than with plain Claude. The exported SRT

[05:39] looked like the other two. At this point, all three versions worked in the app. I had not checked their exact timing yet. Okay, the results. Time first. Plain Claude took nine minutes and 42 seconds. Graphify finished at 9:15. CodeGraph came first at eight minutes and 45 seconds. Graphify looks close until I include its first index build. The index pushed that total to 12 minutes and 44 seconds. CodeGraph’s index added less than two seconds,

[06:09] so its total stayed around 8:47. Its planning phase was also 40% faster than plain Claude. Plain Claude and Graphify both needed 28 navigation calls during planning. CodeGraph needed 17. Now the tokens. Plain Claude used 6.55 million, while Graphify reduced that to 5.34 million. CodeGraph used 4.23 million, which was 35% below the baseline. Graphify dropped the API-equivalent cost

[06:41] from $5.16 to $4.29. CodeGraph went lower again at $3.71. I ran these through my subscription, so I did not pay those amounts directly. Graphify also had its separate indexing session. Gemini cost around 14 cents. Claude used another $2.15 while driving the workflow. Together, the first Graphify index came to about $2.30 before the feature work. You normally build the full index once,

[07:11] and it stays on disk. As the code changes, you still run an update from time to time. Code updates are local. CodeGraph is more convenient here because its running server updates the index automatically. Changed documents and images may use Gemini again. And now the code quality. All three versions passed their own tests and looked correct in the app. After finishing all three runs, I had Codex audit every exporter with an extreme timeline of 100 one-frame clips. Graphify ended one frame early,

[07:43] which is 33 milliseconds at 30 frames per second. One frame sounds small and the test was extreme, but the error kept growing with every clip. A separate bug could drop a valid word near a cut. Plain Claude had a smaller rounding error of one millisecond. CodeGraph passed both timing checks. So in this run, CodeGraph wins. It used fewer tokens and finished faster. It was also the only implementation that passed both added timing checks. Now about the sample size.

[08:15] One viewer said one run is never enough and asked for a larger task. Another wanted predefined tests. And yeah, this test still has the same sample-size problem. One run per setup cannot prove a general winner. More runs would make the result more reliable. I do these experiments in the evenings and pay through my normal subscriptions. I’m not sponsored by Anthropic or OpenAI. My token limits are very, very real. Claude Code and the models keep changing.

[08:45] The graph tools move just as fast, so a larger benchmark can still become outdated within weeks. Still, these numbers show what happened here. They give you something concrete to try. My main goal is to explain how these tools work. Then you can decide whether either one fits your project. From this run, I would try CodeGraph first. If this video reaches 100 likes within one week, I will run a larger feature. I will add Graft and GitNexus, making it a four-tool comparison.

[09:16] In the meantime, tell me which one you’d use, Graphify or CodeGraph, and why. If you want another token-saving comparison, watch Caveman vs Ponytail vs RTK next. It’s another nine minutes of me staring at the terminal with my cat in the belly-trap pose behind my chair.