Understand Chat
Ask natural-language questions about a repo using a pre-built knowledge graph instead of blind file grepping.
Overview
Understand Chat is a journey-wide agent skill that answers codebase questions from a local knowledge graph—usable whenever a solo builder needs oriented context before committing to changes.
Install
npx skills add https://github.com/lum1104/understand-anything --skill understand-chatWhat is this skill?
- Reads `.understand-anything/knowledge-graph.json` with nodes, edges, layers, and tour
- Greps the graph first to avoid dumping the entire JSON into context
- Supports code types (file, function, class) and domain types (flow, entity, claim)
- Uses edge types such as imports, calls, depends_on, and documents for traversal
- Argument-hint query mode for focused Q&A over the graph
- Graph documents node types across code, config, domain, and knowledge layers
- Key edge types include imports, calls, depends_on, configures, and documents
Adoption & trust: 809 installs on skills.sh; 54.9k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You waste context and time scrolling files because you do not know which modules, flows, or configs actually implement the behavior you care about.
Who is it for?
Builders who already have or will generate `.understand-anything/knowledge-graph.json` and want repeatable agent Q&A over that index.
Skip if: Greenfield empty folders with no prior graph analysis step, or questions that need live production metrics instead of repository structure.
When should I use this skill?
Use when you need to ask questions about a codebase or understand code using a knowledge graph.
What do I get? / Deliverables
You get graph-grounded explanations that cite node summaries and relationships so the next step—plan, fix, or extend—starts from the right files and flows.
- Graph-grounded answers referencing relevant nodes, edges, and tour context
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Map how auth and billing connect before deciding whether to fork or rebuild.
Estimate feature touch points by following flow and step nodes in the tour.
Trace depends_on and calls edges from an endpoint to its data layer.
Confirm which configs and deploy edges change before merging a risky PR.
Re-query the graph after a refactor to see updated module boundaries.
How it compares
Complements raw ripgrep and file reads with a pre-indexed graph layer, not a replacement for running tests or hitting APIs.
Common Questions / FAQ
Who is understand-chat for?
Solo and indie developers using coding agents who maintain a knowledge graph snapshot of their repository for faster orientation.
When should I use understand-chat?
In idea/discover when evaluating a fork, in build when tracing a feature across modules, in ship/review when validating blast radius, and in operate/iterate when debugging unfamiliar paths.
Is understand-chat safe to install?
It reads project-local graph JSON; confirm what data your graph contains and review the Security Audits panel on this page before install.
SKILL.md
READMESKILL.md - Understand Chat
# /understand-chat Answer questions about this codebase using the knowledge graph at `.understand-anything/knowledge-graph.json`. ## Graph Structure Reference The knowledge graph JSON has this structure: - `project` — {name, description, languages, frameworks, analyzedAt, gitCommitHash} - `nodes[]` — each has {id, type, name, filePath?, summary, tags[], complexity, languageNotes?} - Code node types: file, function, class, module, concept - Non-code node types: config, document, service, table, endpoint, pipeline, schema, resource - Domain/knowledge node types: domain, flow, step, article, entity, topic, claim, source - IDs use the node type as prefix, e.g. `file:path`, `function:path:name`, `config:path`, `article:path` - `edges[]` — each has {source, target, type, direction, weight} - Key types: imports, contains, calls, depends_on, configures, documents, deploys, triggers, contains_flow, flow_step, related, cites - `layers[]` — each has {id, name, description, nodeIds[]} - `tour[]` — each has {order, title, description, nodeIds[]} ## How to Read Efficiently 1. Use Grep to search within the JSON for relevant entries BEFORE reading the full file 2. Only read sections you need — don't dump the entire graph into context 3. Node names and summaries are the most useful fields for understanding 4. Edges tell you how components connect — follow imports and calls for dependency chains ## Instructions 1. Check that `.understand-anything/knowledge-graph.json` exists in the current project root. If not, tell the user to run `/understand` first. 2. **Read project metadata only** — use Grep or Read with a line limit to extract just the `"project"` section from the top of the file for context (name, description, languages, frameworks). 3. **Search for relevant nodes** — use Grep to search the knowledge graph file for the user's query keywords: "$ARGUMENTS" - Search `"name"` fields: `grep -i "query_keyword"` in the graph file - Search `"summary"` fields for semantic matches - Search `"tags"` arrays for topic matches - Note the `id` values of all matching nodes 4. **Find connected edges** — for each matched node ID, Grep for that ID in the `edges` section to find: - What it imports or depends on (downstream) - What calls or imports it (upstream) - This gives you the 1-hop subgraph around the query 5. **Read layer context** — Grep for `"layers"` to understand which architectural layers the matched nodes belong to. 6. **Answer the query** using only the relevant subgraph: - Reference specific files, functions, and relationships from the graph - Explain which layer(s) are relevant and why - Be concise but thorough — link concepts to actual code locations - If the query doesn't match any nodes, say so and suggest related terms from the graph