Graphify vs CodeGraph: I Tested Both With Claude Code

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: Graphify vs CodeGraph: I Tested Both With Claude Code · Channel: The Gray Cat · 09:16 · Watch on YouTube

Topics: AI agents, AI evaluation and benchmarks, Claude Code, Software engineering with AI, Model inference and optimization

Summary

The video compares plain Claude, Graphify, and CodeGraph on the same Gray Cut feature: exporting word-by-word SRT subtitles that follow edits. All three implementations worked in the app, but CodeGraph used the fewest tokens, finished fastest overall, and passed both additional timing checks. Graphify reduced feature-work tokens but its initial indexing took longer and it had timing issues in the audit. The creator cautions that this was only one run per setup and recommends trying CodeGraph first based on these results.

Key points

• The feature prompt asked Claude to export one SRT cue per retained word, with timings adjusted to the current edit.
• Plain Claude explored the project using its usual search tools; its tests passed and the app built successfully.
• Graphify indexed 219 files and created a visual map, but the first scan needed an additional dependency and a separate Claude installation command.
• Graphify’s index took around three minutes; its Gemini processing of non-code files used about 230,000 tokens, estimated at 14 cents.
• CodeGraph’s index write took under two seconds, used no model tokens, and its running server updates the index in the background.
• Feature runs took 9:42 with plain Claude, 9:15 with Graphify, and 8:45 with CodeGraph; including indexing, Graphify took 12:44 and CodeGraph about 8:47.
• CodeGraph used 4.23 million tokens, compared with 5.34 million for Graphify and 6.55 million for plain Claude.
• In an audit using 100 one-frame clips, Graphify ended one frame early and could drop a valid word near a cut; plain Claude had a one-millisecond rounding error, while CodeGraph passed both checks.
• The creator notes that one run per setup cannot establish a general winner and suggests trying CodeGraph first based on this test.

Chapters

Start	Chapter	Summary
00:00	Comparison setup and feature	The creator introduces Graphify and CodeGraph, explains the word-by-word SRT feature, and describes the shared test setup.
02:02	Plain Claude and Graphify	Plain Claude completes the feature successfully, then Graphify is indexed and tested, with setup issues and limited usefulness during planning.
04:07	CodeGraph setup and feature run	The creator configures CodeGraph, describes its local index and agent tool, and reports that Claude used it during planning.
05:39	Timing, token, and code-quality results	The video compares run times and token use, then reports the implementations’ results on additional timing checks.
08:15	Limitations and conclusion	The creator discusses the small sample size, recommends trying CodeGraph based on this run, and invites viewers to comment.

Quotes

Both can build a queryable map of your project before feature work. — 00:00

During planning, Claude queried Graphify three times and said it barely helped. — 03:36

During planning, Claude called CodeGraph twice. — 05:09

CodeGraph passed both timing checks. — 07:43

From this run, I would try CodeGraph first. — 08:45

Concepts and entities

Graphify, CodeGraph, Claude Code, Claude Opus 5, Gemini 3 Flash Preview, Codex, MCP, The Gray Cut, SRT

Full transcript (original language)

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.