WEBVTT

00:00:00.000 --> 00:00:02.720
Asking an AI to trace a single code base request

00:00:02.720 --> 00:00:07.200
cost 200 ,000 tokens. Then by giving the AI a

00:00:07.200 --> 00:00:10.460
simple map first, that cost dropped to 80 ,000

00:00:10.460 --> 00:00:13.279
tokens. Yeah, that is a massive drop and wasted

00:00:13.279 --> 00:00:15.380
computational effort. I mean, we're literally

00:00:15.380 --> 00:00:17.940
changing the starting line here. Welcome to the

00:00:17.940 --> 00:00:19.600
Deep Dive. I'm really glad you are joining us

00:00:19.600 --> 00:00:21.679
today. We have a pretty fascinating shift to

00:00:21.679 --> 00:00:24.519
talk about. We really do. You know, I still wrestle

00:00:24.519 --> 00:00:27.519
with prompt drift myself, especially when I ask

00:00:27.519 --> 00:00:30.559
an AI to analyze a massive project and it just

00:00:30.559 --> 00:00:33.200
gets hopelessly lost. Oh, absolutely. It's incredibly

00:00:33.200 --> 00:00:35.920
frustrating when it just spins its wheels. Exactly.

00:00:36.179 --> 00:00:38.899
So today we are exploring Graphify. It's an open

00:00:38.899 --> 00:00:41.640
source tool that basically gives cloud code a

00:00:41.640 --> 00:00:43.850
reusable memory. Which is something developers

00:00:43.850 --> 00:00:46.170
have been desperately asking for. Right. We'll

00:00:46.170 --> 00:00:47.789
cover how it builds a map of your repository.

00:00:48.090 --> 00:00:49.969
We'll look at the three -pass system it uses

00:00:49.969 --> 00:00:52.549
to understand your files. And we'll see how it

00:00:52.549 --> 00:00:54.950
fundamentally changes the way AI interacts with

00:00:54.950 --> 00:00:58.450
code bases. Okay, let's unpack this. We know

00:00:58.450 --> 00:01:01.350
AI gets lost in big projects. Why does that actually

00:01:01.350 --> 00:01:03.750
happen? Well, mainly because it totally lacks

00:01:03.750 --> 00:01:06.230
inherent structure when it begins. Right. Normally,

00:01:06.370 --> 00:01:09.390
cloud code searches file by file. It spawns these

00:01:09.390 --> 00:01:12.230
little explore agents, opens folders and just,

00:01:12.310 --> 00:01:14.870
you know, builds context from zero. It's kind

00:01:14.870 --> 00:01:16.849
of like trying to navigate a new city by walking

00:01:16.849 --> 00:01:18.769
down every random alleyway to see where it goes.

00:01:18.849 --> 00:01:21.349
Yeah, exactly. It's chaos. Versus just looking

00:01:21.349 --> 00:01:23.329
at a subway map before you leave the house. Right.

00:01:23.739 --> 00:01:26.180
And GraphDefy fixes this by turning the repo

00:01:26.180 --> 00:01:28.900
into a knowledge graph first. It builds that

00:01:28.900 --> 00:01:31.900
subway map. Why does crawling a repository manually

00:01:31.900 --> 00:01:35.079
eat up so many tokens? Because the AI is wasting

00:01:35.079 --> 00:01:37.040
context windows just trying to figure out the

00:01:37.040 --> 00:01:39.120
shape of the project before it even begins to

00:01:39.120 --> 00:01:41.219
answer the actual prompt. So it builds a map

00:01:41.219 --> 00:01:43.760
first, saving the AI from wandering blindly.

00:01:44.079 --> 00:01:46.260
Yes, exactly. And the way it accomplishes that

00:01:46.260 --> 00:01:49.019
is really methodical. It uses a three -pass approach,

00:01:49.159 --> 00:01:51.640
right? How does it start? Pass 1 focuses purely

00:01:51.640 --> 00:01:54.040
on the code. It uses a tool called TreeSitter

00:01:54.040 --> 00:01:57.299
to read the code structure locally. Classes,

00:01:57.299 --> 00:02:00.019
functions, imports. And this pass is completely

00:02:00.019 --> 00:02:02.140
deterministic. Wait, let me stop you right there.

00:02:02.239 --> 00:02:04.939
What does deterministic mean here? It follows

00:02:04.939 --> 00:02:08.159
strict logical rules without any AI guessing

00:02:08.159 --> 00:02:10.620
involved. Got it. So it just reads the actual

00:02:10.620 --> 00:02:14.120
mathematical connections. Right. No LLM hallucination

00:02:14.120 --> 00:02:19.159
yet. Beat. Then pass to handles audio and video.

00:02:19.319 --> 00:02:22.539
It uses faster whisper to transcribe media files.

00:02:22.740 --> 00:02:26.439
Like internal demo videos or meeting clips. Yeah,

00:02:26.479 --> 00:02:28.400
exactly. Those transcripts are added directly

00:02:28.400 --> 00:02:30.900
to the map. Wow, that is incredibly useful for

00:02:30.900 --> 00:02:32.719
capturing raw institutional knowledge. It's a

00:02:32.719 --> 00:02:36.110
total game changer. Then we hit Pass 3. This

00:02:36.110 --> 00:02:38.469
is where the large language model steps in for

00:02:38.469 --> 00:02:40.810
documents and images. Like PDFs and markdown

00:02:40.810 --> 00:02:43.169
files. What's fascinating here is how it blends

00:02:43.169 --> 00:02:46.409
rigid logic with AI interpretation. It understands

00:02:46.409 --> 00:02:49.250
the business logic in a design PDF and connects

00:02:49.250 --> 00:02:51.530
it back to the code from Pass 1. If Pass 1 is

00:02:51.530 --> 00:02:53.789
free and local, why do we even need the LLM in

00:02:53.789 --> 00:02:57.099
Pass 3? Code is rigid and easy to map, but human

00:02:57.099 --> 00:03:00.520
context, like design PDFs, requires AI to interpret

00:03:00.520 --> 00:03:02.780
the meaning. It reads code rules, exactly, then

00:03:02.780 --> 00:03:05.800
uses AI for the messy human stuff. Exactly. It

00:03:05.800 --> 00:03:08.580
creates a complete picture. So once that map

00:03:08.580 --> 00:03:11.020
is built... What does this web of data actually

00:03:11.020 --> 00:03:13.259
look like in practice? Right. It breaks down

00:03:13.259 --> 00:03:16.539
into three core parts. Nodes, edges, and communities.

00:03:16.860 --> 00:03:19.080
Let's define those for everyone. Nodes are the

00:03:19.080 --> 00:03:22.360
distinct entities, a file, a function, or a document.

00:03:22.620 --> 00:03:25.099
Okay, isolated pieces of information. Mm -hmm.

00:03:25.659 --> 00:03:28.740
Edges are the lines connecting those individual

00:03:28.740 --> 00:03:31.319
nodes, the actual functional relationship. On

00:03:31.319 --> 00:03:34.139
communities. Communities are organic clusters

00:03:34.139 --> 00:03:36.979
of highly related nodes, like neighborhoods in

00:03:36.979 --> 00:03:39.819
our subway map. The developers ran a really great

00:03:39.819 --> 00:03:42.979
demo of this. on the Open Design Repository.

00:03:43.039 --> 00:03:45.219
Yeah, it's a huge open source code base. Perfect

00:03:45.219 --> 00:03:48.800
stress test. Graphify scanned 203 files in about

00:03:48.800 --> 00:03:52.400
six minutes. And it created 197 distinct nodes

00:03:52.400 --> 00:03:57.960
plus over 3 ,400 edges. That is a massive web

00:03:57.960 --> 00:04:00.819
of dependencies. Yeah. And it found 109 communities,

00:04:01.000 --> 00:04:04.020
right? Yeah. It highlights surprising connections.

00:04:04.199 --> 00:04:06.199
It even identifies these things called God nodes.

00:04:06.580 --> 00:04:09.699
Ah, the highly connected critical parts of the

00:04:09.699 --> 00:04:13.379
repo. Whoa. Yeah. Beat. Imagine scaling that.

00:04:13.539 --> 00:04:16.060
Imagine seeing God nodes in a code base you've

00:04:16.060 --> 00:04:18.180
worked on for years but never truly understood.

00:04:18.439 --> 00:04:22.100
Beat. It completely exposes the hidden, fragile

00:04:22.100 --> 00:04:24.819
architecture of your project. What practical

00:04:24.819 --> 00:04:27.279
value does knowing the communities give to the

00:04:27.279 --> 00:04:30.500
AI? It allows clawed code to isolate the specific

00:04:30.500 --> 00:04:33.019
neighborhood of code it needs to solve a problem,

00:04:33.199 --> 00:04:36.689
ignoring irrelevant files entirely. Nodes are

00:04:36.689 --> 00:04:39.529
things, edges are connections, communities are

00:04:39.529 --> 00:04:42.149
specific code neighborhoods. That perfectly summarizes

00:04:42.149 --> 00:04:44.819
it. It's why it beats traditional search. Since

00:04:44.819 --> 00:04:46.899
we're talking about memory, listeners are probably

00:04:46.899 --> 00:04:49.139
wondering how this differs from GraphArea. They

00:04:49.139 --> 00:04:51.319
do sound similar, but the core difference is

00:04:51.319 --> 00:04:53.939
that Graphify does not use embeddings. Let's

00:04:53.939 --> 00:04:56.160
clarify that. What are embeddings? Translating

00:04:56.160 --> 00:04:59.160
text into numbers so AI can find similar underlying

00:04:59.160 --> 00:05:01.339
meanings. Here's where it gets really interesting.

00:05:01.819 --> 00:05:05.620
Graphify maps actual existing structural relationships.

00:05:06.399 --> 00:05:09.339
GraphArea searches giant unstructured document

00:05:09.339 --> 00:05:12.790
collections. Exactly. GraphRag finds things that

00:05:12.790 --> 00:05:15.990
sound related. Graphify reads exact, deterministic

00:05:15.990 --> 00:05:18.970
relationships that already exist, like code imports.

00:05:19.310 --> 00:05:22.029
It's basically RG Lite for repositories. Yeah,

00:05:22.129 --> 00:05:25.709
mapping reality, not probability. So if I have

00:05:25.709 --> 00:05:30.069
10 ,000 messy policy PDFs, I shouldn't use Graphify.

00:05:30.250 --> 00:05:33.509
Correct. GraphRag is for massive, unstructured

00:05:33.509 --> 00:05:36.790
text. Graphify is for structured systems where

00:05:36.790 --> 00:05:39.129
you want to know exactly how A connects to B.

00:05:39.600 --> 00:05:42.339
Graphify map structured systems. GraphRag searches

00:05:42.339 --> 00:05:45.319
giant piles of loose documents. Spot on. You

00:05:45.319 --> 00:05:47.639
have to choose the right tool for the job. Let's

00:05:47.639 --> 00:05:50.339
get back to the practical payoff. Time, money,

00:05:50.420 --> 00:05:52.220
and keeping this map alive. The token savings

00:05:52.220 --> 00:05:55.399
are very real here. In that test, asking Claude

00:05:55.399 --> 00:05:57.800
to trace a design request, the standard run cost

00:05:57.800 --> 00:06:01.800
200 ,000 tokens. And 150 ,000 of those were wasted

00:06:01.800 --> 00:06:04.160
just on explore agents. The AI was just frantically

00:06:04.160 --> 00:06:06.540
bumping into walls. Right. But the Graphify run

00:06:06.540 --> 00:06:09.279
took only 80 ,000 tokens total. That is about

00:06:09.279 --> 00:06:11.959
40 % of the original cost. Now, I do want to

00:06:11.959 --> 00:06:14.759
warn listeners not to expect the massive 70 times

00:06:14.759 --> 00:06:17.259
token savings hype you might see online. Yeah,

00:06:17.300 --> 00:06:19.540
the internet loves to exaggerate. Always. But

00:06:19.540 --> 00:06:22.420
40 % is still massive for big projects. And setup

00:06:22.420 --> 00:06:24.959
is incredibly easy. You just ask Cloud Code to

00:06:24.959 --> 00:06:27.800
install it. You just run slash graphify dot.

00:06:27.959 --> 00:06:31.040
And there's this really cool dash dash obsidian

00:06:31.040 --> 00:06:33.600
flag. Which turns the map into an obsidian vault

00:06:33.600 --> 00:06:36.540
for personal notes. It's so fun to visually explore

00:06:36.540 --> 00:06:39.519
your code base that way. But code changes daily.

00:06:39.800 --> 00:06:43.240
How do we keep this a living repo? You run Graphify

00:06:43.240 --> 00:06:46.360
hook install. It rebuilds the map automatically

00:06:46.360 --> 00:06:49.199
on every single commit. If my team pushes 50

00:06:49.199 --> 00:06:52.180
commits a day, won't updating this map get incredibly

00:06:52.180 --> 00:06:54.540
expensive? No, because the structural code updates

00:06:54.540 --> 00:06:57.319
don't use the LLM API. They just use the local

00:06:57.319 --> 00:07:00.139
free parsing tool. The hook updates the map locally

00:07:00.139 --> 00:07:02.360
and for free on every commit. It's completely

00:07:02.360 --> 00:07:06.240
sustainable. So what does this all mean? Graphify

00:07:06.240 --> 00:07:08.839
isn't just a cost -saving trick. No, not at all.

00:07:08.920 --> 00:07:10.860
If we connect this to the bigger picture, it's

00:07:10.860 --> 00:07:12.800
a fundamental shift in how we work with these

00:07:12.800 --> 00:07:15.839
tools. We are moving from treating an AI like

00:07:15.839 --> 00:07:18.120
a search engine that has to rediscover your project

00:07:18.120 --> 00:07:20.579
every morning to giving it a permanent living

00:07:20.579 --> 00:07:23.180
memory. This raises an important question about

00:07:23.180 --> 00:07:26.120
the future of development. It gives the AI genuine

00:07:26.120 --> 00:07:29.699
situational awareness. Think about the obsidian

00:07:29.699 --> 00:07:33.449
export feature. If Graphify can instantly map

00:07:33.449 --> 00:07:36.529
the complex logic of a massive software project

00:07:36.529 --> 00:07:38.990
and turn it into a visual vault, actually wait.

00:07:39.209 --> 00:07:41.970
What happens when we start pointing these deterministic

00:07:41.970 --> 00:07:44.170
mapping tools at our own personal hard drives,

00:07:44.269 --> 00:07:46.009
our personal notes, or our scattered thoughts?

00:07:46.189 --> 00:07:49.329
Two -sex islands. That is a pretty wild concept

00:07:49.329 --> 00:07:51.290
to think about. Try pointing Graphify at your

00:07:51.290 --> 00:07:53.269
messiest project this week just to see the map

00:07:53.269 --> 00:07:55.250
it generates. Thanks for joining us on this deep

00:07:55.250 --> 00:07:55.449
dive.
