Understand Anything: The AI Skill That Turns Code into Interactive Knowledge Graphs

The Way We Read Code Is Being Rewritten

Taking over an unfamiliar open-source repository and facing hundreds of thousands of lines of code, just figuring out "who calls whom" can eat up an entire day. This is a pain that nearly every engineer has experienced during onboarding. But in the era of large language models, the first move in reading code is quietly changing—from opening an editor and jumping to definitions one by one, to letting AI first generate a "map you can ask questions to."

A GitHub skill called Understand Anything is a prime example of this trend. According to an analysis by Bilibili creator ValleyAI (StarPaw column), the project just surpassed 75,000 stars, ranking second on the June monthly leaderboard. It can perform static analysis on any codebase and directly generate an interactive knowledge graph. You can click open each node, trace call relationships layer by layer, and even ask questions directly against the graph in natural language.

The project uses the MIT license, with TypeScript as its primary language. The repository recently moved from LUM1104 to EgoNexi, and currently boasts 75,000+ stars and 6,000+ forks. The official positioning is blunt: this is a "graph that teaches you, not a pretty graph"—emphasizing practicality over visual flair.

Supplement: What is static analysis

Static analysis refers to the technique of extracting program information by parsing the syntactic structure and symbolic relationships of source code, without actually running the program. It typically first parses code into an abstract syntax tree (AST), then performs symbol resolution, type inference, and reference tracking to identify structural information such as function definitions, call sites, and import dependencies. Static analysis is widely used in compilers, code linters (such as ESLint), and IDE go-to-definition features. Its advantage is comprehensive coverage without needing a runtime environment, but its inherent limitation is equally obvious—any behavior determinable only at runtime, such as dynamic dispatch, reflection calls, or module names assembled from string concatenation, is difficult for static analysis to capture accurately. This sets the stage for the "sober reminders" discussed later.

The Three Core Capabilities of Understand Anything

Code into Knowledge Graph: Understand Call Relationships at a Glance

Understand Anything performs a round of static analysis on your repository, extracting functions, classes, and modules as graph nodes, and extracting call relationships, import relationships, and inheritance relationships as edges connecting the nodes, ultimately assembling an interactive graph that can be zoomed, clicked open, and expanded.

Behind this is essentially the application of the knowledge graph data structure in the field of code understanding. A knowledge graph expresses entities and their relationships through nodes and edges. In the code scenario, nodes are typically program entities such as functions, classes, and modules, while edges represent relationships like calls, imports, and inheritance. Once code is converted into a knowledge graph, dependency threads originally hidden in text are made explicit—convenient for humans to browse visually, and also providing structured retrieval context for large language models. Compared to having AI read the entire source code directly (limited by the context window and prone to missing cross-file associations), the graph enables more precise answers.

When you want to see who calls a certain function, what it in turn calls, and which external packages it depends on, you can trace it at a glance—no need to jump back and forth between definitions a dozen times in the editor. For large projects, the value of this global perspective far exceeds that of a README document.

Install Once, Use Everywhere: Cross-Agent Reuse

It is essentially a skill that you install into the context of the agent you use daily. It currently supports mainstream tools like Claude Code, Codex, Cursor, Copilot, and Gemini CLI.

This means whether you're fixing a bug in Claude Code today, adding a feature in Cursor tomorrow, or looking at a new repository with Codex or Gemini CLI the day after, you can directly call up this graph to locate problems. This cross-agent capability relies on the open agent skills specification, which is also a common practice among the top skill-type projects on this month's leaderboard—write once, reuse in many places.

Supplement: The Agent Skills Open Specification

Agent Skills is a capability-encapsulation paradigm that has emerged in recent years alongside the rise of LLM coding assistants. It packages a specific capability (such as generating code graphs or executing database queries) into a module that AI agents can load into their context, following unified invocation conventions, so that the same skill can be reused across different agent host environments. This is similar to the concept of browser plugins or VS Code extensions, but the target audience shifts from humans to AI. Vendors like Anthropic and OpenAI are pushing for the unification of related standards (such as the MCP protocol and tool use specifications), aiming to let developers "write once, reuse in many places," avoiding separate adaptations for each tool, thereby reducing the duplicate labor caused by ecosystem fragmentation.

Ask Questions Directly Against the Graph: Answers with Path References

The third capability best demonstrates its differentiation: you don't need to switch tools—you can ask questions directly in the agent using natural language, such as "Where is this API triggered from?" or "If I change this function, which downstream modules will be affected?"

The skill uses the graph as context, enabling the agent's answers to come with path references rather than blind guesses. This is precisely the biggest difference from ordinary AI code reading—conclusions can be traced back along the graph, making them verifiable and traceable. Technically, injecting the graph as structured context allows tracing back along paths in the graph to specific files and line numbers, thereby significantly reducing the probability of LLM "hallucinations." This is also a typical application of the current retrieval-augmented generation (RAG) approach in the code domain.

Who Should Install This Code Knowledge Graph Skill

According to the video analysis, three groups benefit most from Understand Anything:

• Engineers taking over unfamiliar open-source repositories: Especially when facing large projects, during the first week of onboarding, the graph is ten times better than a README.
• Personnel doing code audits and security reviews: They need to trace suspicious paths along the call chain, and the graph provides a natural traceability perspective.
• Teachers teaching programming or running workshops: Simply projecting the graph on screen lets students grasp the hierarchical structure noticeably faster.

The common premise across these three scenarios is that they all need to quickly build an understanding of the overall code structure—and the graph happens to make this understanding concrete.

Three Sober Reminders Before Using

Before getting carried away by the hype of 75,000 stars, the creator also offers three practical reminders worth keeping in mind for anyone wanting to try it.

First, the graph is the result of static analysis. It cannot reflect "fancy tricks" like dynamic dispatch, reflection calls, or runtime plugin loading. A path that appears broken on the graph may actually be connected at runtime. So the graph is an abstraction and cannot replace actually running the code; critical paths still require runtime verification. This is precisely where the inherent boundary of static analysis lies—for any call relationship that can only be determined at runtime, static parsing is powerless.

Second, there's a performance threshold. The first analysis of a large monorepo may take several minutes to start, and the generated graph can be very dense and may lag. Here, monorepo refers to the strategy of managing multiple projects or modules together in a single version repository. Companies like Google and Meta adopt this approach, and their codebases often number in the millions of lines, so the computational cost of static parsing naturally rises accordingly. Prepare your patience before using it.

Third, it only parses code structure and does not understand business semantics. Questions like "why is it written this way" still require business context and documentation to accompany them—the graph itself can't provide the answer.

A Paradigm Shift Underway

What truly makes Understand Anything worth noting is not just its specific features, but the trend it reflects: in the era of large language models, the first move in reading code is changing.

In the past, we opened the editor, jumped to definitions, and read line by line. Now, more and more developers choose to first let AI generate a conversational, traceable map, then read with questions in hand. This "build the graph first, then ask questions" workflow, combined with the cross-tool reuse capability brought by the open agent skills specification, may become the standard configuration for code understanding work in the future.

Of course, as the sober reminders emphasize, the graph is ultimately an abstraction from a static perspective. No matter how powerful the tool, it cannot replace verifying that code actually runs, nor deep understanding of business semantics. It is a powerful starting point, not an endpoint.

Key Takeaways