Skip to content
Skillpedia
General coding87k · #848

understand

Has your agent analyze a code project. It creates an interactive map to understand the structure, components, and their connections.

What it does

This tool analyzes a project's code to create an interactive visual map. It helps you understand how different parts of the code connect and work together.

When to use it

  • ✓When starting a new project to grasp its structure.
  • ✓When debugging an issue in an unfamiliar part of the code.
  • ✓When reviewing someone else's code.

Example of what to ask your AI

“Analyze the code for this project and create a knowledge graph.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/skills/understand/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/skills/understand/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool reads all code files, identifies components and their relationships, and generates a special file (`knowledge-graph.json`) that can be viewed on an interactive dashboard.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add Egonex-AI/Understand-Anything --skill understand

Or download just the file:

curl -L https://raw.githubusercontent.com/Egonex-AI/Understand-Anything/main/understand-anything-plugin/skills/understand/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

/understand

Analyze the current codebase and produce a knowledge-graph.json file in the project's data directory (.ua/, or the legacy .understand-anything/ when it already exists). This file powers the interactive dashboard for exploring the project's architecture.

Options

  • $ARGUMENTS may contain:
    • --full — Force a full rebuild, ignoring any existing graph
    • --auto-update — Enable automatic graph updates on commit (writes autoUpdate: true to $UA_DIR/config.json)
    • --no-auto-update — Disable automatic graph updates (writes autoUpdate: false to $UA_DIR/config.json)
    • --review — Run full LLM graph-reviewer instead of inline deterministic validation
    • --language <lang> — Generate all textual content (summaries, descriptions, tags, titles, languageNotes, languageLesson) in the specified language. Accepts ISO 639-1 codes (zh, ja, ko, en, es, fr, de, etc.) or friendly names (chinese, japanese, korean, english, spanish, etc.). Locale variants supported: zh-TW, zh-HK, etc. Defaults to en (English). Stores preference in $UA_DIR/config.json for consistency across incremental updates.
    • --exclude <patterns> — Comma-separated glob patterns for additional files/directories to exclude from analysis (e.g., --exclude "tests/*,docs/*"). These patterns take highest priority over built-in defaults and .understandignore rules. Supports gitignore syntax including ! negation.
    • A directory path (e.g. /path/to/repo or ../other-project) — Analyze the given directory instead of the current working directory

Progress Reporting

Throughout execution, report progress to the user at each phase transition and during batch processing. This keeps users informed on large codebases where analysis can take a long time.

  • Phase transitions: At the start of each phase, print a status line:

    [Phase N/7] <phase name>...

    Example: [Phase 2/7] Analyzing files (12 batches)...

  • Batch progress: During Phase 2, report each batch with its index and total:

    Analyzing batch X/N (files: foo.ts, bar.ts, ...) (list up to 3 filenames, then ... if more)

  • Phase completion: When a phase finishes, briefly confirm:

    Phase N complete. <one-line summary of result>

    Example: Phase 1 complete. Found 247 files across 3 languages.


Phase 0 — Pre-flight

Determine whether to run a full analysis or incremental update.

  1. Resolve PROJECT_ROOT:
    • Parse $ARGUMENTS for a non-flag token (any argument that does not start with --). If found, treat it as the target directory path.

      • If the path is relative, resolve it against the current working directory.
      • Verify the resolved path exists and is a directory (run test -d <path>). If it does not exist or is not a directory, report an error to the user and STOP.
      • Set PROJECT_ROOT to the resolved absolute path.
    • If no directory path argument is found, set PROJECT_ROOT to the current working directory.

    • Worktree redirect. If PROJECT_ROOT is inside a git worktree (not the main checkout), redirect output to the main repository root. Worktrees managed by Claude Code are ephemeral — the data directory (.ua/, or legacy .understand-anything/) written there is destroyed when the session ends, taking the knowledge graph with it (issue #133). Detect a worktree by comparing git rev-parse --git-dir against git rev-parse --git-common-dir; in a normal checkout or submodule they resolve to the same path, in a worktree they differ and the parent of --git-common-dir is the main repo root.

      COMMON_DIR=$(git -C "$PROJECT_ROOT" rev-parse --git-common-dir 2>/dev/null)
      GIT_DIR=$(git -C "$PROJECT_ROOT" rev-parse --git-dir 2>/dev/null)
      if [ -n "$COMMON_DIR" ] && [ -n "$GIT_DIR" ]; then
        COMMON_ABS=$(cd "$PROJECT_ROOT" && cd "$COMMON_DIR" 2>/dev/null && pwd -P)
        GIT_ABS=$(cd "$PROJECT_ROOT" && cd "$GIT_DIR" 2>/dev/null && pwd -P)
        if [ -n "$COMMON_ABS" ] && [ "$COMMON_ABS" != "$GIT_ABS" ]; then
          MAIN_ROOT=$(dirname "$COMMON_ABS")
          if [ -d "$MAIN_ROOT" ] && [ "${UNDERSTAND_NO_WORKTREE_REDIRECT:-0}" != "1" ]; then
            echo "[understand] Detected git worktree at $PROJECT_ROOT"
            echo "[understand] Redirecting output to main repo root: $MAIN_ROOT"
            echo "[understand] (Set UNDERSTAND_NO_WORKTREE_REDIRECT=1 to keep PROJECT_ROOT as the worktree.)"
      

…

FAQ

What is a 'knowledge graph'?

It's a visual representation showing the parts of your code (components) and how they link to each other, much like a map.

Can I choose the language for the descriptions in the graph?

Yes, you can specify a language using the `--language` option followed by the language name or code (e.g., `--language english` or `--language en`).

What happens if the code changes?

You can ask the tool to analyze again. There's an option (`--auto-update`) to have it automatically update the graph whenever you save code changes.

Details

Original description by the author

Analyze a codebase to produce an interactive knowledge graph for understanding architecture, components, and relationships

repo: Egonex-AI/Understand-Anything

Popularity

GitHub stars
87k
Ranking position
#848
License
MIT
Updated
10/12/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills