Skip to content

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.