You join a new team, you clone the repo, and you open the code base. And there it is, a 200,000
line code base looking at you like a deer in the headlights. So you do what every dev does, you grep, we jump between files and we probably ask Claude to explain this repo. What if you got a map, a real interactive map that teaches you the code base? Flows, architecture layers, change impact,
this is understand anything. And it's already hit over 14,000 stars on GitHub in weeks and a lot of devs have been talking about it. In the next minute, I'll show you how this works and how it's gonna immensely speed up your understanding of your code base.
Understand anything is an open source Claude code plugin.
It can also fit into workflows with tools like cursor, copilot, and Gemini CLI.
You point it at a repo in even a knowledge base and it turns that project into a queryable interactive knowledge graph.
It does this with static analysis plus multi agent LLM processing. But the important part is not the tech stack. The important part is the part it actually solves because every dev has had this problem.
You are new to some kind of legacy code base, legacy app. The docs are outdated.
The engineer who knew everything
left six months ago, and your AI coding agent just keeps guessing over and over again. That is where this tool becomes really helpful. So let's run it. If you enjoy coding tools to speed up your workflow, be sure to subscribe. We have videos coming out all the time. Now here's a medium sized project. It's big enough to be really annoying, but small enough that I can actually show you how cool this is.
It's just a repo I cloned from Google microservices
and it's small enough that we can actually test this without having to pretend anything.
First, I'm gonna install the plugin. Right here in Claude, plugin install understand anything. Once this generates, we need to reload the plugins of course, and then we just have to run understand.
Now it's gonna scan the entire repo. It pulls out structure,
relationships,
key modules,
and likely business concepts.
Now we can run the dashboard command to launch everything. Now first, this took ages to run, like thirty minutes, and it burned a boatload of tokens. So having a good Claude plan is a must. I have clawed max and this used 25% of my rate, so it burns and it burns fast.
But once it is done, we can open this dashboard, and this is the really cool part that really hits home. I can zoom out and see high level architecture, I can zoom in and access internal parts.
I can click to see the code breakdown and how all this code is connected.
I can even click in and view the actual code itself.
Then I can search for something here like payments.
Now normally, I'd be jumping between through routes, services, models, handlers, just docs that aren't even useful anymore, and here the tools pull the pieces together.
Now I can click guided
tour and it walks through the flow in order. The entry point, the validation, the logic, database, external APIs,
air handling.
That's already really useful. This guided tour breaks everything down, we can go into it, access the different components. That's the difference between hey, this is a really cool graph and I would actually check this before touching production code.
But now the obvious question here is,
don't we already have tools like this? As devs, we don't really need any more pretty dashboards.
We need less wasted time and this tool goes after one of the biggest time syncs in software.
Getting context, right? Where is all this connected? How is it useful? People are testing it on large projects, legacy Java monoliths, microservice repos,
hundreds of files,
and the reaction is kinda what I got here. This would have saved me my first two weeks in the job because it breaks everything down, it connects everything, and it shows us how it's intertwined.
That's the first really big use case, onboarding. So instead of saying read these 12 pages and ask around if anything's confusing,
that's already confusing, we can now say open the graph, take the tour, then we can ask better questions.
Now, the second really good use case is AI agents because most AI coding tools are only as good as the context that we give them. If the agent sees three files, it's just gonna guess. If it has a structured map of the system with domains, flows, dependencies
and actual explanations,
it has a better chance of making the right change in the first place. Then of course, there's refactoring, right? Before we touch the code, we can now ask, what does this code depend on? What flow does it belong to? What might break if it moves?
That is how you avoid turning a one line change into a major event.
And this is the real reason devs are pretty excited about this project. Not because we care about diagrams, I like diagrams, right? They're cool, they're useful and visual, but we hate being lost. Now, this is where we need to be careful because devs have seen code visualization tools before.
IDE graphs, source graph style navigation, NX graphs, tree setter visualizers,
and a lot of them have the same exact problem.
What do they do? They show structure,
but they don't explain the actual meaning. They tell you this file imports that file. Great,
but why? What flow is this a part of? Where does the request start? What breaks if I change it? That's the missing layer. Understand anything is trying to add that layer. Instead of only showing as a typescript file or something else, it tries to turn into something closer to an actual flow of how things work. That's the big things here. From files to meaning, from imports to system behavior, from here are the pieces to here is how the machine works. Compared to many LLM or rag code tools,
it is also more visual and more teachable.
A lot of AI code tools are basically just search boxes. You ask a question, you get an answer. This gives you a full on breakdown
helping us understand
where everything is going, what's intertwined, how it's connected with allowing us to actually see the code. Now, let's talk about what people actually like. The obvious win here was onboarding. If you're joining a large code base, this gives you a good starting point. Also, the architecture layers, right? These are really built out. You can start at the system level and then drill down into modules and implementation details.
Diff impact is another big one. Every experienced dev knows the fear of making a tiny change in a code base they don't actually understand yet.
For Claude code users, the graph can also become better context. So instead of dumping random files into a prompt,
you give the agent structured architecture knowledge.
It's also free, MIT licensed,
incremental and designed to work across multiple dev environments. Now, the skeptical side, when a project blows up this quickly, we start to ask the question, is this useful or did it just win the GitHub algorithm?
That's a good question to ask. There are also the LLM dependencies,
that means token cost.
This
blew up on token cost. So it took a while, it took a lot of tokens,
make sure you have a good plan if you're gonna use this. You still need good judgment, this just gives you that overview. It doesn't replace reading code, it just helps you understand it better where everything is going. If you enjoy coding tools and tips like this, be sure to subscribe to the BetterStack channel. We'll see you in another video.