I Tested 6 Code Graph Tools—Here Is What Actually Happened
Read the Portuguese translation →
Author: The Gray Cat · Watch on YouTube
Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.
Original language: English
Original video: I Tested 6 Code Graph Tools—Here Is What Actually Happened · Channel: The Gray Cat · 08:15 · Watch on YouTube
Topics: AI agents, AI evaluation and benchmarks, Claude Code, AI developer tools
Summary
Section titled “Summary”The Gray Cat compares six code graph tools with plain Claude Code on the same app redesign task, using identical project copies, prompts, and design files. CodeGraph had the lowest cost and finished fastest in this test, while its implementation also best matched the creator’s preferences, though it still had bugs. The results are limited by being one run per setup, and the creator notes that timing, cost, and tool benefits may vary. They conclude that plain Claude Code performed well too and that extra tools have not consistently improved results in their recent comparisons.
Key points
Section titled “Key points”- The six tools tested were CodeGraph, Graphify, Graft, GitNexus, Codebase Memory MCP, and Code Review Graph; plain Claude Code was the comparison baseline.
- All seven sessions used Opus 5.5 at medium effort, with no subagents, and received identical project code, prompts, and design files.
- The task was to implement a redesigned start screen, settings, and editor interface in The Gray Cut.
- CodeGraph used about 17.6 million tokens and cost about $8.66, compared with 19.5 million tokens and $9.18 for plain Claude Code.
- The middle four tools had costs within about 35 cents of one another; the creator cautions against drawing strong conclusions from one run each.
- Graft used about 39% more tokens and cost about 23% more than plain Claude Code, despite reporting roughly 486,000 tokens saved.
- Astra’s review found bugs in every implementation, even though builds and regression tests passed; CodeGraph preserved saved before-and-after video durations that five other versions missed.
- CodeGraph finished in about 19 minutes, while plain Claude Code took about 23.5 minutes; overlapping runs could have affected timing.
- The creator chose CodeGraph for this task but says plain Claude Code did well and that extra tools have not consistently improved results.
Chapters
Section titled “Chapters”| Start | Chapter | Summary |
|---|---|---|
| 00:00 | The comparison and coding task | The creator introduces six code graph tools and explains the shared app redesign task and controlled test setup. |
| 02:11 | How the tools work and cost results | The video describes each tool’s approach and compares token use and costs, highlighting Graft’s unexpectedly high usage. |
| 05:36 | Implementation review and timing | The creator reviews the implementations, reports bugs and quality differences, and compares how long the sessions took. |
| 07:12 | Conclusion and next comparisons | The creator explains why CodeGraph was the pick for this task while noting that plain Claude Code performed well and inviting suggestions for future tests. |
Quotes
Section titled “Quotes”They all aim to make code easier to find and reduce how much Claude needs to read. — 00:00
I wouldn’t read much into the ranking after one run each. — 04:29
Astra’s review still found bugs in every implementation, even though their builds and regression tests passed. — 06:09
This doesn’t prove CodeGraph made Claude faster. — 07:12
But adding another tool hasn’t consistently improved the result. — 07:43
Concepts and entities
Section titled “Concepts and entities”CodeGraph, Graphify, Graft, GitNexus, Codebase Memory MCP, Code Review Graph, Claude Code, Opus 5.5, Fable, Astra, MCP
Full transcript (original language)
Section titled “Full transcript (original language)”00:00 I was going to make more videos comparing code graph tools in Claude Code. You kept suggesting tools across my comparison videos, and I kept writing the names down. But testing a different pair on a different feature each time felt incomplete. For this test, I picked CodeGraph, Graphify, Graft, GitNexus, Codebase Memory MCP, and Code Review Graph. That’s six popular tools all tackling one substantial coding task alongside plain Claude Code. They all aim to make code easier to find and reduce how much Claude needs to read.
00:34 Every coding session used Opus 5.5 at medium effort, without subagents. I’ll show you how I organized the test and which setup came out ahead. I’ve been adding AI editing to The Gray Cut with Astra. The feature was coming together, but I wasn’t happy with the interface. So I sent screenshots to Claude Design, and it came back with something more adequate. The task was to bring that design into the app.
01:05 That meant rebuilding the start screen and settings, then updating the editor’s UI as well. Last time, I handled these comparisons manually and kept missing things. This time, I used Fable to prepare the environments and oversee the runs. Each setup got its own copy of the project, starting from identical application code. I gave every session the same prompt and design files. I explicitly prohibited subagents in the prompt. All seven sessions followed that instruction; the logs show zero subagents.
01:38 I removed Ponytail and Serena from the shared instructions, and kept the rest consistent. The runs overlapped in groups. I was worried about burning through my subscription, but after the first batch I still had room to continue. I’ll leave the prompt on screen. All six tools scan the code and record connections between its parts. Claude can then find a function and check what depends on it. Some give Claude tools through MCP; others use terminal commands. Hooks can also add information automatically during the session.
02:11 CodeGraph maps function calls and references, and watches for changes to keep that map updated. Claude can query it through MCP. CodeGraph’s prompt hook supplied the graph information here, without Claude calling its MCP tools. Graphify also groups connected code into related areas. Claude used Graphify’s CLI here, so it queried the graph through terminal commands. Its hooks kept reminding Claude to check the graph before opening files. Graft builds a map of function calls and writes reference files describing the code.
02:46 It supports MCP and terminal commands; this run used MCP. Hooks also add context automatically, including notes about what an edit could affect. GitNexus follows connections between functions to identify larger flows through the application. Here, Claude used its MCP tools to check what changes might affect. A hook also added related code information to some searches. Codebase Memory MCP stores a searchable map locally. Claude uses its MCP tools to find functions or follow connections between them.
03:21 Hooks also add context around searches and file reads. Code Review Graph builds a map of functions and their connections, which Claude queries through MCP. It also offers a separate review workflow for checking changes and suggesting tests. In this run, Claude used it to understand the existing code before editing. Okay, so here are the results. CodeGraph came out cheapest, with plain Claude Code second CodeGraph used about seventeen point six million tokens, compared with nineteen point five million for plain.
03:54 Those totals count cached input again whenever it appears in another request. They don’t mean Claude generated millions of words. CodeGraph used about ten percent less but the cost difference was smaller. At the API prices used here, it came to eight dollars sixty-six, against nine dollars eighteen for plain. That’s about six percent less, or fifty-two cents. I ran these through my subscription, so these amounts are comparison figures. The middle four tools were within about thirty-five cents of each other.
04:29 I wouldn’t read much into the ranking after one run each. Codebase Memory MCP’s result comes from a replacement run. The table counts the seven selected coding sessions. Setup and discarded attempts are excluded, along with orchestration and review costs. Graft was the surprise. You’d asked about it quite a lot, and I expected more. It used about thirty-nine percent more tokens than plain, and cost about twenty-three percent more. Yet its own report claimed roughly four hundred eighty-six thousand tokens saved.
05:03 That estimate compares its answers with reading whole files. It doesn’t measure what Claude actually avoided reading. This reminds me of RTK, where shortened output left Claude needing another command to check the build result. Extra requests can cancel those savings. Graft made ninety-two model requests here, against seventy-two for plain. Missing context could explain some of that, but this run doesn’t establish the cause. If you’d like to help keep these comparisons coming, you can support me on Patreon
05:36 Setting up these tests takes time, and I still need to check what the agents actually built. Your support helps me spend more time on that work and try the tools you keep sending me. So if these videos help you decide what to use, consider becoming a patron. Subscribe here for the next comparison, and join Discord if you’d like to suggest tools or discuss the results. Both links are in the description. Looking at the interfaces, all seven versions seemed pretty close to what I wanted. I’ll show you the CodeGraph version beside the design.
06:09 Astra’s review still found bugs in every implementation, even though their builds and regression tests passed. CodeGraph restored the saved before and after video durations when reopening a project. Five other versions missed that. It still hides some controls after editing or undoing an edit. I’ll fix the findings in that version, then run it through my usual quality pipeline before using it. So CodeGraph is my pick from this test. Time matters too, especially when I’m just waiting for an agent to finish.
06:42 CodeGraph finished in about nineteen minutes. GitNexus was close, less than half a minute behind. Plain took about twenty-three and a half minutes. So CodeGraph finished roughly four minutes earlier Graft took almost twenty-six minutes, which puts plain ahead of it on time as well as cost. The other tools landed between GitNexus and plain. You can see their times in the table. These runs overlapped in different groups, which could affect timing.
07:12 This doesn’t prove CodeGraph made Claude faster. Still, four minutes is noticeable when I’m staring at a terminal or clicking around YouTube while the agent works. For me, waiting for an agent is the most exhausting part of this new way of working. Reducing that wait matters just as much as the token count. So I’d choose CodeGraph for this task. It had the lowest cost, and I prefer its implementation despite the remaining bugs. Plain Claude Code still did pretty well.
07:43 With Opus 5.5 at medium effort, I’m increasingly comfortable starting without these extra tools. My recent comparisons used different tasks and setups. But adding another tool hasn’t consistently improved the result. The models have also changed since these tools appeared. Maybe older or cheaper models have more room to benefit from help finding the right code. Let me know if you want this test in Codex, and which model I should use. Or would cheaper models through OpenCode be more useful to you?
08:15 My cat’s suggestion is to close the terminals and shut down the computer. Then give her all my attention and get back to petting her. Thanks for watching. For my earlier Graphify and CodeGraph comparison, watch this video used Opus 5 on a different feature.