Understand Anything Review: Code Knowledge Graph Plugin

Originally published on andrew.ooo — visit the original for any updates, code snippets that aged out, or follow-up posts.

TL;DR

Understand Anything is a Claude Code plugin (also runs on Cursor, Codex, Copilot, Gemini CLI, OpenCode, OpenClaw, and 7 more harnesses) that scans your project with a 5-agent pipeline, builds a knowledge graph of every file, function, class, and dependency, and gives you an interactive dashboard you can pan, search, and ask questions about. It's the most polished answer yet to the "I just joined a new team and the codebase is 200,000 lines, where do I start?" problem.

Key facts:

• 53,178 GitHub stars, 8,807 new this week — among the fastest-growing repos on GitHub right now
• Multi-agent analysis pipeline — project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer (plus optional domain-analyzer)
• Tree-sitter + LLM split — deterministic structural facts (imports, calls, classes) from Tree-sitter; semantic summaries and layer assignments from the LLM
• Interactive dashboard — force-directed graph colored by architectural layer (API, Service, Data, UI, Utility), with plain-English node summaries, guided tours, fuzzy/semantic search, and diff impact analysis
• Commit-the-graph workflow — the output is .understand-anything/knowledge-graph.json; teammates can pull the repo and skip the pipeline entirely
• Incremental updates — a post-commit hook patches only the files that changed
• Multi-language UI — generates node summaries and dashboard labels in en, zh, zh-TW, ja, ko, ru
• 13 supported platforms — Claude Code (native), Cursor, VS Code Copilot, Copilot CLI, Codex, OpenCode, OpenClaw, Antigravity, Gemini CLI, Pi Agent, Vibe CLI, Hermes, Cline, KIMI CLI, Trae

If you've tried to use Karpathy-style LLM wikis or wished CodeGraph had a visual front-end you could hand to a non-engineer, this is the project to install this week.

Quick Reference

Field	Value
Repo	Lum1104/Understand-Anything
Live demo	understand-anything.com/demo
Author	Yuxiang Lin (Lum1104)
License	MIT
Stars	53,178 (+8,807 this week)
Primary install	/plugin marketplace add Lum1104/Understand-Anything (Claude Code)
Other platforms	One-liner installer: `curl -fsSL .../install.sh \
Output	{% raw %}.understand-anything/knowledge-graph.json
Trendshift rank	#1 trending this week

What Understand Anything Actually Is

Strip away the marketing and Understand Anything is doing three things in one package.

First, it's a multi-agent code-analysis pipeline. You run /understand inside a project and five agents take over: a project scanner detects languages and frameworks, a file analyzer pulls functions/classes/imports out of each file (using Tree-sitter, so the same input deterministically produces the same edges), an architecture analyzer tags each node with a layer like API/Service/Data/UI/Utility, a tour builder generates ordered learning walkthroughs, and a graph reviewer validates the result. Files run in parallel — up to 5 concurrent batches of 20–30 files — and incremental updates re-analyze only what changed since the last commit.

Second, it's a static JSON artifact you commit to your repo. The graph lives in .understand-anything/knowledge-graph.json. Teammates clone the repo and skip the entire pipeline — they just open the dashboard. Pull request authors include the updated graph in the PR. For monorepos with 10+ MB graphs, the README explicitly recommends Git LFS.

Third, it's an interactive web dashboard. You open /understand-dashboard and get a force-directed graph you can pan, zoom, click into individual nodes for plain-English summaries, switch into a domain view that maps code to business processes (auth flow, payment flow, session management), and run /understand-diff against your current branch to see ripple effects before you commit.

The combination matters more than any single piece. CodeGraph (which we reviewed in May) ships a pre-indexed knowledge graph but no GUI — it's optimized for an agent reading the JSON. Understand Anything inverts the priority: the graph is also for humans. That's what you want when a junior dev or PM asks "what happens when someone clicks Checkout?"

Why It's Trending NOW

Three forces are converging.

Agentic plugins finally have a marketplace. Anthropic shipped Claude Code plugins earlier this year, Cursor shipped its plugin spec two weeks ago, and VS Code Copilot v1.108+ auto-discovers plugins from .copilot-plugin/plugin.json. Understand Anything is one of the first projects to ship a real plugin manifest for all of them at the same time — install commands for Claude Code, Cursor, VS Code Copilot, Codex, Gemini CLI, and seven more harnesses are right in the README.

The "AI reads the codebase" problem is everyone's problem now. Two months ago colbymchenry/codegraph made the case that pre-indexing beats reading files on demand: fewer tokens, fewer tool calls, 100% local. Understand Anything extends that argument with a visual layer and adds business-domain mapping. The dev.to writeup that helped kick the repo into hyperscale framed it bluntly: "you join a new team, the codebase is 200,000 lines, no docs worth reading."

Karpathy's LLM-wiki pattern is going mainstream. The /understand-knowledge command points at a Karpathy-style wiki (an index.md linking to per-concept files via wikilinks) and builds a force-directed knowledge graph from it. It's the same idea behind Obsidian, but with LLM-extracted entities and implicit relationships layered on top. The wiki pattern only works if the graph is navigable — and that's exactly what Understand Anything ships.

Key Features (With Code)

1. Install in any agentic IDE

For Claude Code:

/plugin marketplace add Lum1104/Understand-Anything
/plugin install understand-anything

For Codex, OpenCode, OpenClaw, Gemini CLI, etc. — one installer, pick the platform:

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.sh | bash -s codex

# Windows (PowerShell)
iwr -useb https://raw.githubusercontent.com/Lum1104/Understand-Anything/main/install.ps1 | iex

Cursor and VS Code Copilot auto-discover the plugin when you clone the repo — no install step. The installer clones to ~/.understand-anything/repo and symlinks the right files for the platform; updates via ./install.sh --update.

2. Generate the graph

/understand

That's it. The five agents fan out, scan the project, and write .understand-anything/knowledge-graph.json. For a monorepo:

# Scope to a subdirectory
/understand src/frontend

# Localize node summaries + dashboard UI
/understand --language ja

# Auto-update on every commit via a post-commit hook
/understand --auto-update

The --auto-update flag is the one I'd reach for on any active repo: it incrementally patches the graph so each commit lands with a matching graph, which is exactly what you want for PR reviews.

3. Explore the dashboard

/understand-dashboard

The dashboard opens in your browser. You see a force-directed graph color-coded by architectural layer. Click a node, get a plain-English summary plus the underlying file. Switch to Domain View for a horizontal graph laid out as business processes — auth flow → session management → permission check. This is the view you hand to a PM.

4. Ask questions

# Plain-English Q&A
/understand-chat How does the payment flow work?

# Impact analysis on the current diff
/understand-diff

# Deep-dive into one file
/understand-explain src/auth/login.ts

# Onboarding guide for new hires
/understand-onboard

# Business-domain extraction
/understand-domain

/understand-diff is the unsung hero here. Instead of reading every file your branch touches and guessing what breaks, you get a ripple report — "this change to src/db/session.ts affects auth/login, auth/refresh, and the WebSocket handshake." That's the missing piece between "I changed something" and "I'm confident in the PR."

5. Wikify a knowledge base

/understand-knowledge ~/path/to/wiki

Point it at a Karpathy-pattern LLM wiki and the deterministic parser extracts wikilinks and categories from index.md, then an article-analyzer agent discovers implicit relationships, extracts entities, and surfaces claims — turning the wiki into a navigable graph of interconnected ideas. This is genuinely novel: most "second brain" tools want you to draw the edges; this one infers them.

Architecture and How It Works

The split between deterministic and semantic is the cleanest part of the design.

Tree-sitter (deterministic) parses source into a concrete syntax tree and pulls out the structural facts that don't need an LLM: imports, exports, function and class definitions, call sites, inheritance. It pre-resolves into an importMap during the scan phase so the file-analyzer agents don't have to re-derive imports from raw source. Same input → same edges, every run. It's also what powers fingerprint-based change detection for incremental updates.

LLM (semantic) reads the parsed structure alongside the original source and produces what parsers can't: plain-English summaries, tags, architectural-layer assignments, business-domain mapping, guided tours, and language-concept callouts (closures, decorators, generics — explained where they actually appear).

This is the same split that makes Tree-sitter-based dev tools like ast-grep reliable: you don't ask the LLM "is this a function call?" (it'd guess), you ask it "what is this function FOR?" (it can read intent). The result is a graph that's reproducible on the structural side and intelligent on the semantic side.

The five-agent topology:

Agent	Role
project-scanner	Discover files, detect languages and frameworks
file-analyzer	Extract functions, classes, imports → nodes + edges
architecture-analyzer	Identify architectural layers (API/Service/Data/UI/Utility)
tour-builder	Generate guided learning tours, ordered by dependency
graph-reviewer	Validate completeness and referential integrity
domain-analyzer	Extract business domains/flows/steps (used by /understand-domain)
article-analyzer	Extract entities and implicit relationships (used by /understand-knowledge)

File analyzers run in parallel — up to 5 concurrent agents handling 20–30 files per batch. On a fresh project of, say, 1,500 files, that's roughly 60 batches over 12 parallel slots. Plan for 5–15 minutes of LLM time on a first run, then a few seconds per commit on incremental updates.

Real-World Use Cases

From the issues, dev.to writeups, and the project's own examples:

• Onboarding new hires. Run /understand once, commit the graph, and the next person who clones the repo gets /understand-onboard for a guided tour ordered by dependency. The Better Stack walkthrough video on YouTube is built around exactly this case.
• PR reviews. The /understand-diff impact report goes in the PR description. Reviewers see the ripple before they open the diff.
• Codebase audits. Architecture-analyzer's layer tags surface the parts of the system that don't fit cleanly into any layer — usually the parts that need refactoring.
• Cross-team handoffs. Domain view maps code to business processes, which is the artifact platform engineers and product managers actually want.
• Reference architecture exploration. The maintainers ship a fork of GoogleCloudPlatform/microservices-demo with a committed graph — a polyglot reference (Go/Java/Python/Node) you can open in the dashboard and learn from.
• LLM-wiki navigation. Point /understand-knowledge at a Karpathy-style wiki and turn a flat folder of notes into a force-directed graph with community clustering.

First Impressions From the Community

The repo crossed 53K stars in about a month — among the steepest curves on GitHub right now, with star-history showing +533 stars/week sustained even after the initial spike. Trendshift ranks it #1 globally for the week. The dev.to writeup that helped kick it off framed it as "the missing onboarding tool for the agentic-IDE era" and a Better Stack YouTube walkthrough was uploaded shortly after release.

What people consistently call out:

• The dashboard is the moat. Tools that ship a JSON graph are common; tools that ship a graph plus a visual interface that non-engineers can use are rare.
• Domain view is the killer feature for product/eng handoffs. Several issues are requests to extend it (export to Mermaid, embed in Notion).
• The five-agent pipeline produces visibly better summaries than single-shot "explain this codebase" prompts. Tour-builder ordering by dependency is what makes it feel like a curriculum, not a dump.

Honest pushback:

• Incremental updates are great after the first run, but the first run on a large monorepo costs real LLM tokens.
• Domain view quality depends heavily on naming hygiene. Codebases with cryptic module names get cryptic domains.
• Some issues report the graph reviewer rejecting valid edges on languages with less-mature Tree-sitter grammars (R, OCaml).

Getting Started

# 1) Install in Claude Code
/plugin marketplace add Lum1104/Understand-Anything
/plugin install understand-anything

# 2) Generate the graph for the current repo
cd ~/code/my-project
/understand

# 3) Open the dashboard
/understand-dashboard

# 4) (Optional) commit the graph so teammates skip the pipeline
git add .understand-anything/
echo ".understand-anything/intermediate/" >> .gitignore
echo ".understand-anything/diff-overlay.json" >> .gitignore
git commit -m "Add Understand Anything knowledge graph"

# 5) (Optional) auto-update on every commit
/understand --auto-update

For Cursor or VS Code Copilot users, step 1 isn't needed — clone a repo that already has .cursor-plugin/plugin.json or .copilot-plugin/plugin.json and the plugin is auto-discovered.

Two minutes of setup, then you have an interactive map of your codebase you can hand to anyone on the team.

Who Should Use This (And Who Shouldn't)

Use it if:

• You're onboarding into a codebase larger than 20K lines
• You're trying to do PR reviews where the change crosses module boundaries
• You're handing off architecture to product or platform teams who don't want to read code
• You're building a wiki/second-brain and the manual linking is killing you
• You're already on Claude Code, Cursor, Copilot, Codex, or one of the 13 supported harnesses

Skip it if:

• Your codebase is small enough to fit entirely in one LLM context window — you don't need a graph, you need a cat *.ts.
• You're on a language with weak Tree-sitter support (R, OCaml, Elixir) — the structural side of the pipeline will be patchier than the README implies.
• You're philosophically against committing generated artifacts to a repo (the "commit the graph" workflow is the killer ergonomic; without it the tool is mostly local).

Comparison With Alternatives

Tool	Output	Dashboard	Multi-platform	Domain mapping
Understand Anything	JSON graph	✅ Force-directed + domain view	✅ 13 platforms	✅ Built-in
CodeGraph	JSON graph	❌ Agent-facing only	✅ Many	❌
Sourcegraph Cody	Embedded index	✅ Web UI	Cody only	❌
Aider repo-map	Markdown summary	❌	Aider only	❌
Continue context provider	Embeddings	❌	Continue only	❌

CodeGraph is the closest competitor and the obvious complement: CodeGraph is optimized for agents (smaller graph, fewer tokens, no UI), Understand Anything is optimized for humans-plus-agents (richer graph, dashboard, domain view, more LLM time). If your goal is "make Claude Code use fewer tokens reading my repo," CodeGraph wins. If your goal is "make the whole team understand the repo," Understand Anything wins.

Honest Limitations

• First-run cost. A fresh scan on a large monorepo means thousands of LLM calls in the file-analyzer phase. Incremental updates are cheap; the cold start is not. Budget for it.
• Tree-sitter coverage varies. TypeScript, Python, Go, Java, Rust — excellent. Niche languages — mileage varies.
• Domain view depends on naming. If your modules are named module-a/b/c, domain extraction can only do so much.
• Dashboard is mostly read-only. You can't edit the graph from the UI; corrections happen in source and are picked up on the next run.
• No telemetry transparency about LLM call counts. You see the agents working; you don't get a built-in token-cost report. (Open issue from May 28.)

These aren't dealbreakers, but they're the things you'd hit on day two and want to know on day zero.

FAQ

How is Understand Anything different from CodeGraph?

Both build a knowledge graph of your codebase, but they optimize for different consumers. CodeGraph ships a graph for the AI agent — smaller, faster, no UI — to cut tokens and tool calls. Understand Anything ships a graph for humans and agents — richer summaries, an interactive dashboard, a business-domain view — for onboarding, PR reviews, and cross-team handoffs. Many teams run both.

Does it work without Claude Code?

Yes. The README lists 13 supported platforms: Claude Code (native), Cursor, VS Code Copilot, Copilot CLI, Codex, OpenCode, OpenClaw, Antigravity, Gemini CLI, Pi Agent, Vibe CLI, Hermes, Cline, KIMI CLI, and Trae. Cursor and VS Code Copilot auto-discover the plugin; the rest install via the one-liner install.sh with a platform argument.

Can I commit the knowledge graph to my repo?

Yes — that's the recommended workflow. Commit everything in .understand-anything/ except intermediate/ and diff-overlay.json. Teammates clone and skip the pipeline. For graphs larger than 10 MB, the README recommends tracking the JSON files with Git LFS.

How does the multi-agent pipeline differ from a single "explain this repo" prompt?

A single prompt has to do scanning, parsing, summarization, and validation in one shot — and forgets earlier files as new ones come in. Understand Anything's five-agent pipeline splits the work: a deterministic Tree-sitter scan first, then specialized agents for file analysis, architecture, tour generation, and validation. The graph reviewer catches dangling references the single-prompt approach misses. File analyzers run in parallel batches of 20–30, so it also scales better.

What languages does it support?

Anything with a Tree-sitter grammar — TypeScript, JavaScript, Python, Go, Java, Rust, C/C++, Ruby, PHP, C#, Swift, Kotlin, and many more on the structural side. The LLM-semantic side is language-agnostic. Niche grammars (R, OCaml, some functional languages) have rougher structural extraction.

Is the dashboard self-hosted?

Yes. /understand-dashboard spins up a local web server and opens the graph in your browser. Nothing leaves your machine except the LLM calls during analysis. The hosted understand-anything.com/demo is just for evaluation — your own dashboard runs locally.

---

Repo: Lum1104/Understand-Anything · Live demo: understand-anything.com/demo · License: MIT