Comparing Understand Anything and Graphify for Codebase Exploration

If you use AI to research your codebase, you definitely need to check out two powerful tools: Understand Anything and Graphify. Both turn your entire codebase into an interactive knowledge base that you can explore with natural language questions – and both help you save AI tokens during research. In this article, we’ll walk through how to set up each tool, compare their token consumption, visualizations, AI query responses, onboarding workflows, stale data handling, and support for local models. By the end, you’ll know which tool fits your project best.

Setting Up Both Tools

Installing Graphify

Graphify relies on Python and the uv package manager (similar to npm for Python). First, install Graphify using uv:

uv install graphify
uv install graphify-skills

Then add it to your project’s terminal – typically by cloning the repository and adding the plugin through the marketplace.

Installing Understand Anything

Understand Anything is installed via the plugin marketplace. Copy the plugin installation command, clone the repository, add it to the marketplace, then install it at the project level:

# Add plugin to marketplace
# Then run installation command
# Choose option 'project level' when prompted

Once both are installed, you can run initial analysis commands.

Token Consumption: Initial Codebase Analysis

We tested both tools on the same codebase (approx. 2000 candidate files, filtered to 1500 using ignore rules). The results:

• Understand Anything consumed 200,000 tokens to generate a full knowledge graph.
• Graphify consumed about half that (100,000 tokens) for the same codebase.

If token budget is your primary concern, Graphify is the clear winner.

Visualizations: Graph Dashboard Comparison

Understand Anything Dashboard

After running /understand dashboard, you get an interactive web UI. It shows:

• Project overview with layers and connection counts.
• Click any layer (e.g., Feature Components) to see all components.
• Each component reveals its full parent-child tree.
• Hovering over nodes shows summaries and usage locations.

This makes it easy to trace dead files, understand dependencies, and refactor confidently.

Graphify Dashboard

Graphify produces an HTML graph file (open with open graph.graph.html). It shows all files as nodes connected by edges, but:

• Nodes are labeled only as “neighbors” – no parent/child distinction.
• Clicking a node shows its connections, but not the hierarchy.
• Less intuitive for humans to navigate.

Winner for visual understanding: Understand Anything.

AI Queries: Using Both Tools for Research

We asked both tools the same question: “Explain the receipt-transaction matching algorithm.”

Graphify Response

• Outputs a table and a list of files with raw text.
• Provides a brief textual explanation but no step-by-step flow.
• Token usage: ~20,000 per query.

Understand Anything Response

• Shows the file origin (e.g., the anim workflow converted to an app).
• Displays a step-by-step table (Step 1, Step 2, Step 3) with files involved.
• Includes a flowchart-like visualization (textual) of how uploading receipts works.
• Token usage: similar to Graphify (~20,000).

Winner for clarity and completeness: Understand Anything.

Onboarding: Converting Codebase into Documentation

Graphify Onboarding

Generates a wiki folder containing 77 articles (one per file or module). Each article is added to your local directory. Great if you prefer having a full wiki you can browse offline.

Understand Anything Onboarding

Summarizes the entire codebase into a single Markdown file. The summary includes:

• Project overview
• Architecture layers
• Key components and their roles

Both are competitive: choose wiki style (Graphify) or summarised overview (Understand Anything).

Stale Data: Automatic Updates When Code Changes

Both tools support automatic graph updates via Git hooks:

• Graphify: On every commit or branch switch, run /graphify update to refresh the graph.
• Understand Anything: Run /understand all updates – it detects changes and updates the knowledge base accordingly.

Both are equally effective; no clear winner.

Privacy and Local Model Support

• Graphify supports running entirely locally with models like Llama or AWS Bedrock. Set the backend model via environment variables, then start your local model with ollama serve and point Graphify to it.
• Understand Anything does not support a local model by default. It uses whatever provider your IDE is configured to (e.g., OpenAI, Anthropic). For teams requiring full privacy offline, Graphify wins.

Final Recommendation

Use both tools in tandem for the best results:

• Understand Anything for superior visual dashboards and clearer AI explanations.
• Graphify when you need lower token costs and local model support.

For onboarding, pick Graphify if you want a full wiki, or Understand Anything if you prefer a concise summary. Both handle stale data updates equally well.

To get the full cheat sheet and detailed setup guide for both tools, check out the comprehensive resources in our community.