Understand Anything: Turn a Codebase Into a Knowledge Graph
By Flowy · Updated 2026-08-28
Understand Anything is a Claude Code plugin that scans a codebase with a multi-agent pipeline and builds an interactive knowledge graph of its files, functions, and dependencies. Reach for it to onboard new engineers, check a diff's blast radius, map business logic, or turn a Figma file or team wiki into a searchable graph.
What is Understand Anything, actually
Understand Anything is a Claude Code plugin from Egonex-AI, and its whole job
is to turn a codebase you don't know into a knowledge graph you can search,
click through, and ask questions about, instead of leaving you to read files
cold. The repository, Egonex-AI/Understand-Anything, has drawn 78,513
GitHub stars. Flowy indexes 19 components in total: 10 agents that do the
analysis work and 9 skills that a person actually reaches for, covering
codebase mapping, diff review, onboarding, business domain mapping, and even
Figma files and team wikis.
How the graph actually gets built
understand is the entry point. Running it starts a pipeline where each
agent owns one step. project-scanner goes first, producing an inventory of
every project file, the languages and frameworks in use, an import map, and
a rough complexity estimate. file-analyzer then works through that
inventory in batches, pulling out functions, classes, and relationships in
two phases, a structural extraction pass followed by an LLM pass that adds
meaning. architecture-analyzer takes the resulting files and assigns every
one of them to exactly one architectural layer, so the graph groups by
something like API, service, or data, rather than by folder name.
tour-builder then designs a guided walkthrough, 5 to 15 steps, ordered so
the architecture and key ideas are introduced in a sensible sequence instead
of alphabetically. graph-reviewer runs last, checking the finished graph
for correctness and completeness and deciding whether it passes.
What you do with the graph once it exists
understand-dashboard opens an interactive web dashboard so you can pan,
zoom, search, and click into the graph instead of reading raw JSON.
understand-chat lets you ask plain questions about the codebase and get
answers grounded in that graph. understand-explain does the same thing at
a narrower scope, a deep dive on one specific file, function, or module. If
what you don't understand is the graph itself rather than the codebase it
describes, knowledge-graph-guide is the agent built for that: it walks
through how nodes, edges, layers, tours, and the dashboard fit together.
Reviewing pull requests and onboarding new hires
understand-diff reads a git diff or a pull request against the existing
graph and reports what changed, which components are affected, and where
the risk sits, the kind of blast radius question a reviewer would otherwise
reconstruct by hand. understand-onboard runs in the other direction: it
generates an onboarding guide for a new team member from the same
architecture and tour data, instead of a wiki page nobody has kept current.
Mapping business logic, not just file structure
understand-domain, backed by the domain-analyzer agent, extracts
business domain knowledge rather than code structure: the domains, the
business flows, and the process steps connecting them, laid out as a flow
graph. It can run as its own lightweight scan of a codebase, or build on a
knowledge graph understand already produced.
Beyond code: wikis and Figma files
Two skill and agent pairs push the same idea past source code.
understand-knowledge, backed by article-analyzer, points at a
Karpathy-pattern wiki of markdown articles and produces a graph of entities,
claims, and implicit relationships, with related topics clustered together.
understand-figma, backed by design-analyzer, points at a Figma file
through its REST API and builds a design graph of pages, screens,
components, and tokens. design-analyzer's own description is explicit that
it does not invent structural nodes or edges, it only adds summaries, tags,
and a screen's purpose to what the Figma file actually contains.
What happens on a codebase too big for one pass
Large projects get analyzed in batches, and stitching those batches back
into one graph is a mechanical script that can miss things at the seams.
assemble-reviewer is the check on that step: it reviews the merged output
for semantic issues the script itself cannot catch, and recovers nodes and
edges that got dropped between batches.
How do I install it
Flowy indexes Egonex-AI/Understand-Anything from its public GitHub
repository; it doesn't host or bundle the plugin itself. Install from the
listing page linked at the top of this guide, and all 19 components above
become available in that session.
Common questions
- What does the Understand Anything plugin do?
- It scans a codebase with a multi-agent pipeline built around the `understand` skill and builds an interactive knowledge graph of files, functions, classes, and their relationships. From there you can browse it visually with `understand-dashboard`, ask it questions with `understand-chat`, check what a change affects with `understand-diff`, or generate an onboarding guide with `understand-onboard`.
- How many agents and skills does Understand Anything ship?
- Flowy indexes 19 components for `Egonex-AI/Understand-Anything`: 10 agents, such as `project-scanner`, `file-analyzer`, and `graph-reviewer`, that do the analysis work, and 9 skills, such as `understand`, `understand-chat`, and `understand-diff`, that a person actually runs. There are no commands, MCP servers, or hooks in this listing.
- Can Understand Anything map business logic instead of just code structure?
- Yes. The `understand-domain` skill and its `domain-analyzer` agent extract business domains, flows, and process steps from a codebase and lay them out as a flow graph, separate from the architectural graph the `understand` skill builds. It can run as a standalone lightweight scan or build on a graph that already exists.
- Does it only work on source code, or can it read Figma files and wikis too?
- Both. `understand-figma` and its `design-analyzer` agent turn a Figma file into a design knowledge graph of pages, screens, components, and tokens through the Figma REST API, and `understand-knowledge` with `article-analyzer` does the same for a Karpathy-pattern markdown wiki, extracting entities, claims, and relationships between articles.
- What happens if the codebase is too large to analyze in one pass?
- Large projects are analyzed in batches by `file-analyzer`, and the `assemble-reviewer` agent exists specifically to review how those batches get merged back into one graph, catching semantic issues and recovering nodes or edges the merge step drops at the seams. `graph-reviewer` then validates the finished graph for completeness before it counts as done.
