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

The Way We Read Code Is Being Rewritten

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

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

The project is licensed under MIT, with TypeScript as its primary language. The repository was recently transferred from LUM1104 to EgoNexi, and currently has 75,000+ stars and 6,000+ forks. The official positioning is straightforward: this is a graph "that can teach you, not a graph that looks pretty"—emphasizing practicality over visual flair.

Additional note: What is static analysis

Static analysis refers to the technique of extracting program information by parsing the syntactic structure and symbol relationships of source code without actually running the program. It typically first parses the 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 linting tools (such as ESLint), and IDE go-to-definition features. Its advantage is comprehensive coverage without needing to set up a runtime environment, but its inherent limitations are also obvious—any behavior that can only be determined at runtime, such as dynamic dispatch, reflection calls, or module names assembled from string concatenation, is difficult for static analysis to capture accurately. This foreshadows the "reality check" discussed later.

The Three Core Capabilities of Understand Anything

Code Becomes a Knowledge Graph: Understand Call Relationships at a Glance

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

Behind this is the practical 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, the dependency threads originally hidden in the text become explicitly expressed—convenient for humans to browse visually, and also providing structured retrieval context for large language models. Compared to letting AI read the entire source code directly (which is limited by the context window and prone to missing cross-file associations), the graph makes answers more precise.

Want to see who calls a certain function, what it calls in turn, and which external packages it depends on? You can trace it at a glance, without jumping back and forth between definitions in the editor a dozen times. For large projects, the value of this global perspective far exceeds that of a README document.

Install Once, Use Everywhere: Cross-Agent Reuse

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

This means that 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 invoke this graph to locate problems. This cross-agent capability relies on the open agent skills specification, which is also the common approach of the top skill-category projects on this month's leaderboard—write once, reuse everywhere.

Additional note: The Agent Skills Open Specification

Agent Skills is a capability-encapsulation paradigm that has emerged in recent years alongside the rise of large language model programming assistants. It packages a specific capability (such as generating code graphs or executing database queries) into a module that can be loaded into an AI agent's context, and follows 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 has shifted 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 enable developers to "write once, reuse everywhere" and avoid separately adapting for each tool, thereby reducing the redundant labor caused by ecosystem fragmentation.

Ask Questions Directly Against the Graph: Answers with Path References

The third capability is the one that best reflects its differentiation: without switching tools, you ask questions in natural language directly in the agent, 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, so the agent's answers come with path references, rather than baseless guessing. This is precisely the biggest difference between it and ordinary AI code reading—the conclusions can be traced back along the graph, verifiable and traceable. Technically, the graph is injected as structured context, allowing the model to trace back along paths on the graph to specific files and line numbers, thereby significantly reducing the probability of LLM "hallucination." 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

Based on the video analysis, three groups of people can benefit most from Understand Anything:

• Engineers taking over unfamiliar open-source repositories: Especially when facing large projects, in the first week of onboarding, the graph is ten times better than a README.
• People 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 who teach programming or run workshops: Simply project the graph onto the screen, and students will grasp the hierarchical structure noticeably faster.

The common premise of these three scenarios is that they all need to quickly build up an understanding of the overall structure of the code, and the graph happens to concretize this understanding.

Three Reality Checks Before Using It

Before getting carried away by the hype of 75,000 stars, the creator also offers three pragmatic reminders worth keeping in mind for everyone who wants to try it.

First, the graph is the result of static analysis. It cannot reflect "fancy operations" 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 (a single code repository) refers to the strategy of managing multiple projects or modules together in one version repository. Companies like Google and Meta adopt this approach, and their codebases often run to millions of lines, so the computational overhead of static parsing naturally rises accordingly. Set your patience appropriately before using it.

Third, it only parses code structure, not business semantics. Questions like "why was it written this way" still require business context and documentation; the graph itself cannot provide answers.

A Paradigm Shift That Is Happening

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

In the past, we would open the editor, jump 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 mind. This "build the graph first, then ask questions" workflow, combined with the cross-tool reuse capability enabled by the open agent skills specification, may become the standard configuration for future code-understanding work.

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

Key Takeaways