understand
Analyze a codebase to produce an interactive knowledge graph for understanding architecture, components, and relationships
44
47%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./understand-anything-plugin/skills/understand/SKILL.mdQuality
Discovery
32%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description conveys a clear concept—codebase analysis producing a knowledge graph—but lacks explicit trigger guidance ('Use when...') and could benefit from more specific action verbs and natural user keywords. It is moderately distinctive but risks overlap with general code analysis skills.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user asks to visualize code structure, map dependencies, or understand codebase architecture.'
Include more natural trigger terms users might say, such as 'dependency map', 'code visualization', 'module relationships', 'code structure diagram'.
List more concrete actions beyond 'analyze' and 'produce', e.g., 'Identifies modules, maps dependencies, traces call flows, and generates an interactive knowledge graph.'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (codebase analysis) and the primary output (interactive knowledge graph), and mentions what the graph covers (architecture, components, relationships), but doesn't list multiple concrete actions beyond 'analyze' and 'produce'. | 2 / 3 |
Completeness | Describes what the skill does (analyze codebase to produce a knowledge graph) but has no explicit 'Use when...' clause or equivalent trigger guidance, which per the rubric should cap completeness at 2, and since the 'when' is entirely missing, it falls to 1. | 1 / 3 |
Trigger Term Quality | Includes some relevant keywords like 'codebase', 'knowledge graph', 'architecture', 'components', and 'relationships', but misses common user variations like 'dependency map', 'code structure', 'visualization', 'code map', or 'module diagram'. | 2 / 3 |
Distinctiveness Conflict Risk | The 'interactive knowledge graph' output is somewhat distinctive, but 'analyze a codebase' and terms like 'architecture' and 'components' could overlap with general code analysis, documentation, or architecture review skills. | 2 / 3 |
Total | 7 / 12 Passed |
Implementation
62%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is exceptionally thorough and actionable with a well-structured multi-phase workflow, clear decision logic, and explicit validation checkpoints. However, it suffers significantly from verbosity — embedding large scripts inline, including exhaustive reference tables, and providing detailed bash snippets for edge cases like worktree detection and plugin root resolution. The content would benefit greatly from extracting inline scripts to bundled files and moving reference tables to a separate REFERENCE.md, which would dramatically reduce token consumption while maintaining the same functionality.
Suggestions
Extract the inline Node.js validation script (ua-inline-validate.cjs), the .understandignore generator, and the worktree detection logic into bundled script files rather than embedding them in the SKILL.md body — reference them by path instead.
Move the KnowledgeGraph Schema reference tables (Node Types, Edge Types, Edge Weight Conventions) to a separate SCHEMA.md file and reference it, saving ~50 lines of token budget.
Consolidate the plugin root resolution logic into a bundled shell script (e.g., resolve-plugin-root.sh) rather than inlining ~40 lines of bash with extensive error messaging.
Consider splitting Phase 0's many sub-steps (0, 0.5, language config, auto-update config, worktree redirect) into a separate PRE-FLIGHT.md reference document, keeping only the decision table and key commands in the main SKILL.md.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | This skill is extremely verbose at ~600+ lines. It includes extensive inline scripts (Node.js validation script, bash worktree detection, plugin root resolution, .understandignore generation), detailed error messages, and exhaustive edge/node type reference tables. Much of this could be offloaded to referenced files or bundled scripts. Claude doesn't need inline explanations of git worktree mechanics or full Node.js scripts embedded in the prompt. | 1 / 3 |
Actionability | The skill provides fully executable bash commands, complete Node.js scripts, exact file paths, specific JSON schemas, and concrete decision tables. Every phase has copy-paste-ready commands and clear output expectations. The dispatch prompts for subagents are detailed templates with specific variable substitutions. | 3 / 3 |
Workflow Clarity | The 8-phase workflow (0 through 7) is clearly sequenced with explicit phase numbering, gate checks (e.g., >100 files confirmation), decision tables for full vs incremental paths, validation checkpoints (Phase 6 validation with retry), error recovery loops (retry once then continue with partial results), and explicit ordering constraints (fingerprints must succeed before meta.json). The feedback loop for validation issues is well-defined. | 3 / 3 |
Progressive Disclosure | The skill references external agent definitions (agents/project-scanner.md, agents/file-analyzer.md, etc.), bundled scripts (merge-batch-graphs.py, compute-batches.mjs, build-fingerprints.mjs), and language/framework/locale files — showing good structural intent. However, the SKILL.md itself is monolithic with massive inline scripts and reference tables that should be in separate files. The full Node.js validation script (~60 lines), the .understandignore generator (~30 lines), and the worktree detection script could all be bundled scripts rather than inline content. No bundle files were provided to verify references. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
81%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 9 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (845 lines); consider splitting into references/ and linking | Warning |
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 9 / 11 Passed | |
- Repository
- Lum1104/Understand-Anything
- Commit
26edf61
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.