30:40Theo - t3․gg · Tutorial
Mythos is here, it's time to start tokenmaxxing
A 30-minute field report on burning $5,400 of subsidized AI inference in ten days — and what actually came out of it.
June 12thThe argument in one line.
Understand-Anything and Graphify solve the same codebase-mapping problem with opposite tradeoffs — one gives richer visualization and AI responses at twice the token cost, while the other stays lean and supports local models for private codebases.
Read if. Skip if.
READ IF YOU ARE…
- You use Claude Code daily on a large codebase and want AI to understand your architecture without re-reading every file.
- You are evaluating codebase knowledge-graph tools and want a live cost and quality comparison on a real production SaaS.
- You work at a company with code-privacy requirements and need to know whether these tools support local or self-hosted LLMs.
- You already know about Graphify and are wondering whether Understand-Anything is worth adding alongside it.
SKIP IF…
- You are not using Claude Code or a compatible AI coding assistant — both tools are CLI plugins, not standalone apps.
- Your codebase is small enough that Claude can read it in a single context window without a knowledge graph.
The full version, fast.
Two Claude Code plugins — Understand-Anything and Graphify — both index your codebase into a queryable knowledge graph, but they diverge on every meaningful dimension. Understand-Anything consumes roughly twice the tokens to build its graph (~200k vs ~100k on a 1,500-file SaaS), but delivers a superior interactive dashboard with parent/child node hierarchy and richer structured AI responses including flowcharts and step-by-step breakdowns. Graphify generates a flatter but cheaper graph, outputs a wiki folder for onboarding instead of a summary MD, and uniquely supports local LLM backends via Ollama and AWS Bedrock. Both handle stale-graph updates via git hooks. The practical recommendation: run both in parallel and use each for what it does best.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:08
01 · Intro — what both tools do
Hook frames the comparison: both tools turn a codebase into a queryable knowledge graph for Claude.
01:09 – 01:49
02 · Community / sponsor
Host pitches his EricTech School community with weekly live calls and 100+ templates.
01:49 – 02:34
03 · Installation
Graphify installed via UV tool; Understand-Anything installed as a Claude marketplace plugin.
02:34 – 05:40
04 · Cost test — token comparison
Running /understand on 2,679-file SaaS; generates .understandignore to trim to 1,500 files; UA costs ~200k tokens, Graphify ~100k.
05:40 – 09:59
05 · Dashboard test
UA launches interactive localhost dashboard with hierarchical node graph; Graphify outputs static HTML with flat neighbor-only view.
10:07 – 12:38
06 · AI usage test
Same query asked to both; UA returns flowchart + structured steps; Graphify returns dense text. Token usage at query time roughly equal.
12:38 – 13:17
07 · Onboarding output
Graphify generates a wiki folder with 77 articles; UA generates a single ONBOARDING.md with architecture summary.
13:17 – 14:00
08 · Stale graph — auto-update
Both tools support git post-commit hooks to auto-regenerate the graph on new commits or branch checkouts.
14:00 – 15:05
09 · Privacy / Local LLM
Graphify supports --backend ollama and --backend bedrock; Understand-Anything has no local model path.
15:05 – 16:20
10 · Final scorecard + recommendation
Hand-drawn scorecard reveals UA wins dashboard/AI; Graphify wins token cost/local LLM. Recommendation: run both.
Lines worth screenshotting.
- Understand-Anything consumes roughly twice the tokens to build its knowledge graph as Graphify does on the same codebase.
- At query time, both tools use nearly identical token counts — the cost gap is in graph generation, not in answering questions.
- Understand-Anything renders parent and child node relationships in its dashboard; Graphify's HTML output shows only flat neighbor connections.
- Graphify is the only tool of the two that supports local LLM backends, including Ollama and AWS Bedrock, making it the choice for air-gapped or privacy-sensitive codebases.
- Both tools support automatic graph updates on git commit via hooks, so the knowledge graph stays current without manual runs.
- Understand-Anything generates a single ONBOARDING.md summary; Graphify generates a multi-article wiki folder — different formats for different workflows.
- A .understandignore file lets you filter the candidate file list before graph generation, reducing token cost without losing relevant architecture context.
- Running both tools simultaneously and maintaining two graphs is a viable production pattern — use UA for visual exploration, Graphify for cost-sensitive or offline queries.
Two tools, one problem — and why you might run both.
WHAT TO LEARN
The right codebase knowledge-graph tool depends on whether you optimize for visual clarity and AI response richness or for token efficiency and data privacy.
- Generating the knowledge graph is where the token cost gap lives — at query time, both tools charge roughly the same; the 2x difference accumulates at index time.
- Hierarchical node visualization (parent, child, sibling) is meaningfully more useful for architectural research than a flat neighbor graph — it tells you direction, not just proximity.
- A .understandignore or equivalent scope-filter file is worth setting up before your first graph generation; filtering 2,679 files to 1,500 can halve the index cost with no loss of relevant architecture.
- Local LLM support is a binary requirement for regulated or proprietary codebases — if your code cannot leave the building, Graphify with Ollama is the only option of the two.
- Both tools implement git hook-based auto-update, so a knowledge graph does not have to become stale; treat the initial setup as a one-time cost, not a recurring burden.
- Onboarding output format is a real workflow preference: a wiki folder suits teams that want browsable documentation per component; a single summary MD suits solo developers who want one document to hand to a new AI session.
Terms worth knowing.
- Knowledge graph
- A structured representation of a codebase as a network of nodes (files, components, functions) and edges (imports, dependencies, relationships), enabling AI to navigate architecture without reading every file in full.
- Understand-Anything
- An open-source Claude Code plugin that indexes a codebase into an interactive, hierarchical knowledge graph with a localhost web dashboard and guided tour.
- Graphify
- An open-source Claude Code skill that converts a codebase into a queryable knowledge graph output as an HTML file and JSON, with support for local LLM backends.
- .understandignore
- A configuration file, similar to .gitignore, that tells Understand-Anything which directories and files to exclude from its analysis to reduce cost and noise.
- UV
- A fast Python package manager used as an alternative to pip, often described as npm for Python; used here to install the Graphify CLI tool.
- Ollama
- An open-source tool for running large language models locally on your own machine, used with Graphify's --backend ollama flag to keep codebase data off external servers.
- AWS Bedrock
- Amazon's managed service for running foundation models in a private cloud environment; supported by Graphify as an alternative to public LLM APIs.
Things they pointed at.
Lines you could clip.
06:23
“Understand anything consumes double of what we have generated using Graphite.”
10:47
“I would definitely say that understand anything definitely gives you a better response.”
13:38
“If you prefer a wiki, then definitely Graphify. If prefer a summarization, then definitely understand anything.”
15:36
“My recommendation is that you can try to use both and have two graphs here maintained in your repository.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogy
00:00If you're using AI here to do research on your codebase, then you definitely need to check out this repository called understand anything. Essentially, this repository here can turn any codebase into a interactive knowledge base that you can actually be able to explore and ask questions and also help you to save AI tokens when doing research similar to Graphify, which I actually made a video on on this channel.
00:19And in this video, I'm gonna not only show you exactly how to set up your NSN Anything, but I'm also gonna show you the difference between NSN Anything and Graphify. For example, how much token does it consume? What does the knowledge graph look like for Graphify?
00:32And what does the knowledge base look like for the NST Anything? And then we're also gonna take a look at a live demo on how we can be able to use this to do AI queries, to do research, how much token it saves, and what is the response it gets. So that's why in this video, I'm gonna show exactly how to set up both Graphite and NSN Anything onto your local projects and how we can be able to use it and what is the difference between the two.
00:54So with that being said, if you're interested, let's get into the video. Now before we continue, I recently launched our school community where I help you to master AI agents, automations, and so much more. And that's all coming from someone who used to work as a senior AI software engineer at companies like Amazon and Microsoft.
01:10And in this community, you're gonna get over a 100 plus video materials like templates and workflows that I personally built and sold over a 100 plus times. On top of that, you're also gonna get access to our weekly live calls. And just to give you an idea, this week, we're actually running a Clawcode masterclass where we're gonna dive into how to improve Clawcode's accuracy when we're gonna use it to build the applications.
01:29Plus, you're also gonna get full community support where you're get a chance to ask questions and get direct answers back. So if you're ready to level up, make sure to jump right in, and I'll see you in a community. Alright.
01:38So to get started, here you can see we have Graphify on the left and NS10 Anything on the right. So to install the Graphify first, let's take a look at this. Right?
01:46So the documentation here, can see this is the prerequisite, making sure that we have Python and UV. So UV is kinda like NPM but for Python.
01:54And all we're gonna do here is just gonna install the Graphite here through the UV tool. So here you can see I have installed the Graphite using UV and also installing the Graphite skills onto my CloudMD and also the skill as well. But simply, if you wanna do the same, like install the understand anything onto repository, it's also very simple.
02:13So scrolling down here, you can see it has a quick start. So it tells you install the plugins through the marketplace in Cloud Code. In So this case, I'm gonna copy this command right here.
02:22So simply, I'm just gonna clear this and start a new ClawCode session. So here, I'm gonna add these plugins into our marketplace first. So now you can see it's gonna clone the repository, and it's going to add this into our marketplace.
02:35And then what we're gonna do here is to install the plugins through the marketplace after we added it. So in this case, I'm gonna run this. And then in terms of the plugin details on where we wanna install this, I'm gonna choose the second option to install on this project level.
02:48Alright. So now once we have both the Graphify and the Understand Anything installed, next thing I'm gonna do here is try to basically do a cost test and see how much token and time it really took to basically converting the entire code base into a knowledge graph. So in this case, this time, I'm gonna start from understand anything and try to see how it works.
03:07So simply, all I'm gonna do here is I'm gonna come to a terminal and just gonna do the slash understand, which will analyze the entire codebase to produce a interactive knowledge graph. In this case, I'm gonna enter this right now.
03:18And then here you can see it has identified there are 2,000 candidate files. This is a very large analysis. So here you can see it gives me some scope that we can choose.
03:26Either we can choose the core applications, like the app folder, the libraries, the components, or we can also just do library only or the whole app proceed anyways or understand ignore, which will exclude any parts that we don't want, like tests, fixtures, storyboard, anything like that, then we just run on what's left.
03:45So rather than just having it to decide on what's core and what's not important, I'm just gonna use a understand ignore to ignore things that are not really relevant. Right?
03:54So this is gonna be setting a really good foundation because in the future, we might be adding things, and this will basically allow us to set on exactly, okay, what are some things that we shouldn't have it to generate a graph? Maybe it's about a data schema or maybe about some mock data or some mock ups, some storybook, right, to just the UI component stuff or maybe some testing stuff or backlog that we shouldn't even worry about, then maybe we can be able to add that inside of our understand ignore so that we can be able to manually change it so that we don't have to always prompt it in the AI.
04:24So in this case, I'm gonna select that and have it to generate a understand ignore first, and let's see what it does first. Okay.
04:31So the understand ignore here is all set, so filtered down to 1,500 files now, and so here's the breakdown. So now if I were to open this really quickly, and this is the ignore.
04:41Right? So we have our test coverage, our generated stuff from, like, Graphify. There's also some backlog docs.
04:48So let's say if you want to include docs, you can just remove that. Right? So this is basically the files that we wanna ignore.
04:54Okay. So then you can see it asking some additional questions to trim more. So pick directories to also in exclude.
05:00So for example, the migrations. So I don't think migrations are really relevant. It just looks through the schema instead of the migration.
05:07So migration is like the changes that we've made on our database, so we don't need to keep track of that. There's also constant variables, types, dev.
05:16I don't think we make a big difference to exclude those. And there's also, like, email templates. I'm basically just gonna proceed forward.
05:22Okay. So finally, you can see we have proceed forward, and now you can see we have different sub agents here. It's split into different batches and try to process and analyze those files here at different batches.
05:33So in this case, let's wait for a bit until it fully processed. Okay. So finally, you can see we have our understand anything for dashboard is fully generated, and now you can see this is how much token has consumed and also how many nodes and edges it has generated.
05:47Okay. So now I'm going to show you how we can use the graphite here to generate the graph. So simply, all we're do here is just gonna copy the slash graph dot, and that's gonna be the command.
05:55Start a new colloquial session, paste that command, and it's going to generate the entire graph, which you can see here. So it's gonna start generated, and it's gonna ask me first question, which is similar to understand anything, about the scope for the knowledge graph. So in this case, because I already have defined the understand ignore on what are the files we're going to ignore or exclude, so I'm just going to pass that and basically mention that please exclude any files that we have in the ignore file and only include the ones that we haven't specified.
06:23So now you can see it has mentioned that and it has generated a graph, and this is how much token has consumed and also how long it took. And this is compared to the understand anything. You can see understand anything consumes double of what we have generated using Graphite.
06:37And definitely, that's gonna be a part of the consideration if you are on a budget for tokens. But for now, let's take look at the graph that it generated. And to start for a dashboard test, let's try out with the understand anything first to see what the dashboard look like.
06:50Simply, all I had to do here, just gonna do slash understand dashboard. So I'm gonna head over to the terminal for the colloquial sessions. Just gonna do the slash understand dashboard, and it's gonna generate a URL that we can click and view the dashboard for the graph.
07:03Alright. So finally, you can see it generates the entire graph for the entire projects, which only consumes around 200,000 for the token consumption, and now here we are.
07:13So here you can see this is the project overview. We have different sections for the entire projects and also how many connections we have for each layers that we have. And furthermore, if I want to look into a particular layer, for example, the feature components, I click on it, and I can also be able to see all the components that we have inside of it.
07:29So here is the entire graph connections. So here we have our matching page. Right?
07:34And here we if we scroll all the way to the left, we have our reports page. And for each component, can see if I were to click on it, it shows you the entire componentry. So here is the match items table, and instead of table, we have configurations, we have empty states.
07:49And for empty state, if I were to click on this, I can also trace it down to the components that are used inside of that component. Right? So if I were to trace it down, it's actually inside of the shared component layer.
07:59There is a file called the step guide dot t x x. And furthermore, you can see it gives you a summary of that component of that t x x file, what it does. And if I were to click on a different one, it gives you a different definition, and it tells you where it was being used.
08:13Right? So it's much more easier. Let's say if I were to say, okay.
08:16Well, this file here is not being used at all. Maybe it's a dead file. Right?
08:19So there's no connections imported, and maybe we shouldn't even use this instead of application. Right?
08:25So it's much more simpler for you to, like, refactor code, understand the code base a bit more, and helping you do a better research for your code base. Right? So you can see that's pretty much the UI, what it offers for helping you to understand and helping you to do research about your code base.
08:37So the next thing we're gonna take a look at is how we can be able to open our graphite outputs, which is saved inside of HTML. So in that case here, I'm gonna head over to the graphite really quickly, and I'm just gonna do the open graphite graph dot html. And now if I were to open this, this is what it looks like.
08:54So you can see we have all the components here are cluttered inside of a single graph. So you can see we have these files here, right, these reports, and furthermore, you can see if I were to click on one of them or deselect anything, right, for example, billing page, and let's say if I were to dive deep into a particular page, like billing page, for example, right?
09:14So you can see inside of the billing page, we have a bunch of neighbors, right, so a bunch of nodes that are connected, but there's no way for me to see the parents or kinda like they're , Right? So there's no parent node, no child nodes. It doesn't specify that.
09:28It just specify they're all neighbor nodes. Right? Before I understand anything, I can see the reference for the parents and the child nodes, or in this case, you can see for this component, it is referencing this matching interface right here.
09:40Right? So I can clearly see the difference there. So this is the parents, this is the child nodes, and for each child nodes here, can see it gives you a description and also gives you the function that it defines, as well as the connections, and also the exports as well.
09:53So you can see that there's a lot of detailed things that we can do. So especially if you're doing research and try to understand the codebase, Anderson Anything definitely has a better visuals for helping you to do research on your codebase.
10:03Alright. So just to recap, Anderson Anything has consumed 200 k's for token consumption so far, and Graphite definitely wins on this one. So in terms of the dashboard visualizations, Understand Anything definitely win on this one because it has a better visualizations, and it's much more easier for human here to understand.
10:20So Understand Anything definitely wins on this one. Okay. So next up we're gonna take a look at is our AI usage test.
10:26And the core question we're trying to ask is, can AI here be able to use Graphite or understand anything and try to query the information that we need? And furthermore, how much token has consumed and how long does it take? Right?
10:38So that's the core question we're trying to answer and try to compare the difference between the two. So if I were to open a terminal really quickly, you can see we have understand anything, asking the same question, and also Graphite here also start a new terminal session with Clock Code and asking the same question.
10:54So one is using the graphite explain and the other one here is using the understand anything for understand explain, and both of them is asking the same question. So you can see for understand anything is triggering the understand explain scale, and it basically just gonna generate the response. Now right off the bat, I would definitely say that understand anything definitely gives you a better response, but you can see the difference here.
11:16I'll show you this in a second. So for the graphite here, you can see this is what the response that it generates for me. So the receipts transaction matching algorithm, here it shows your table, and furthermore, you can see it shows you a bunch of files, bunch of rules, and just bunch of text.
11:30Right? And entirely, can see this how much token has consumed and how long it took. And in terms of understand anything, you can see it's much more visualized.
11:39It just shows you where it is, shows you the file first, and it shows you where it came from, which is the NAN styling binary match. So luckily, this application was actually coming from a NAN workflow, so I convert that workflow into an application that you see here, and that's why it actually has go pretty deep to find that it was actually coming from a NAN style.
11:59And furthermore, you can see it gives you a same table, which they all find the exact same answer. And in terms of the files here, you can see it also gives you the detail algorithm like the step one, step two, step three, which is something that Graphite doesn't have. It just gives you a bunch of text.
12:15Right? So you can see it gives you a flowchart, which is how it works. So upload receipts and user open the model.
12:21Right? So it's much more visualized, much more easier to understand, but furthermore, you can see the token here is roughly around the same. And the time here, the token, roughly around the same for both of them.
12:31But definitely, I would say that understand anything here definitely gives you a much more easier way for you to visualize, understand, and also gives you the similar token usage compared to Graphite.
12:42Okay. So last part that I wanna go over here is the onboarding process. So the onboarding process here, you can see both of them actually offer a similar feature.
12:49So for Graphi here, it's actually converting the entire code base into a single Wiki, and the understand anything here is actually converting everything and summarize it into a single MD file. So that's the difference between the two.
13:01And you can see here that this is what it looks like after I summarize it with the project overview, the architecture layers. Right? So this is what it looks like for the onboarding dot MD file that Anderson Anything generates.
13:11And in terms of Graphite here, it's just gonna add in a wiki including the 77 articles that we have inside of our local directories. So it's just gonna be a wiki folder which contains all the documentations that we have. And that's basically the difference between two.
13:24Honestly, in my opinion, I feel like onboarding process, both of them have their competitive advantage. If you prefer a wiki, then definitely Graphify. If prefer a summarization, then definitely understand anything.
13:34Alright. So the next session we need look at is the still data. So how do we make sure that our graph here is updated when we're making changes?
13:41So right here, can see both of them, like Graphify and also Understand Anything, also has the auto update workflow. So every time we do a git commits or when you check out to a different branches, it's gonna automatically run the slash graphite updates, which will automatically update the graph based on the latest changes.
13:58And for the understand anything, it's following a similar approach. So if you do the slash understand auto updates, it's gonna automatically update based on the latest change that you have inside of your commits. So for that, I would definitely say that understand anything and Graphite here both wins on this one.
14:13Okay. So the last part we wanna talk about here is privacy and local model. So Graphite here supports local model, which you can see here.
14:20So every command that we do, like graphite extract, I can do specify the back end model we're gonna use. For example, using Olama or using Bedrock from AWS.
14:28You can also specify that and making sure that you set the environment variables is going to call the back end API or the back end local model. And all you have to do here, just gonna do the alarm serve, making sure your local model here is running, and you can be able to call it. But in terms of understand anything here, can see it actually doesn't support that by default.
14:47So no local model path documented, and your code actually goes to whatever provider your ID is wired to. And as you can see, that's pretty much the difference between Understand Anything and the Graphite here in terms of the local model.
14:59So pretty much you can see that's it for this video. In this video, we went over a deep comparison between Understand Anything and Graphify.
15:06Alright. So now to show you the difference between the two for Understand Anything and Graphify, you can clearly see that one consumes more token, but definitely gives you a better visualization in terms of dashboard, AI usage, while it still supports functionality like onboarding process and supporting auto update for still data.
15:23And the only thing that Understand Anything here doesn't support is your local large language model. And that's pretty much the difference between Understand Anything and Graphify. And my recommendation is that you can try to use both and have two graph here maintained in your repository and try to work on it at the same time.
15:38For example, for better visualizations, you can try to use understand anything, and for lower token consumptions, you can try to use graphite instead. And, of course, if want to get the full guide that I have wrote in this video for the shortcuts and also the cheat sheets, everything about graphite and the understand anything, make sure you check and check out our school community where you can download it and use it for your projects.
16:00Pretty much that's it for this video, and if you do find out on this video, please make sure to like this video. Consider subscribing for more content like this. But with that being said, I'll see you in the next video.
The Hook
The bait, then the rug-pull.
Two tools promise to give Claude a permanent map of your codebase, cutting the token cost of architectural research. One is newer and flashier. This is a live test — same codebase, same questions, same clock — to find out which one actually delivers.
Named ideas worth stealing.
10:07list
Six-Dimension Codebase Tool Comparison
- Token Consumption
- Dashboard
- AI Usage
- Onboarding
- Stale Data
- Local LLM
A structured six-criteria rubric for evaluating any codebase knowledge-graph tool, applied live to UA vs Graphify.
Steal forany tool-comparison video or written guide evaluating developer productivity tools
How they asked for the click.
VERBAL ASK
15:36product
“make sure you check out our school community where you can download the full guide and cheat sheets”
Soft sell placed after the conclusion, not interrupting the comparison. Low friction — directs to a free community with paid tier.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
