data-structure-protocol

Give agents persistent structural memory of a codebase — navigate dependencies, track public APIs, and understand why connections exist without re-reading the whole repo.

Quality

60%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Critical

Do not install without reviewing

Fix and improve this skill with Tessl

tessl review fix ./skills/data-structure-protocol/SKILL.md

Quality

Content

67%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A solid, well-structured skill that provides actionable CLI-based guidance for maintaining a codebase structure graph. Its main weakness is verbosity in the introductory and conceptual sections, which explain motivations and concepts Claude doesn't need spelled out. The workflow guidance and command reference tables are strong, though adding explicit validation/verification steps after graph mutations would improve reliability.

Suggestions

Trim the opening 2 paragraphs and 'Core Concepts' preamble significantly — remove motivational text like 'LLM coding agents lose context' and 'DSP is NOT documentation for humans'; jump straight to what DSP stores and how.

Add an explicit verification step to the workflow: after bootstrap or batch updates, run `detect-cycles` and `get-orphans` to validate graph integrity before considering the update complete.

Consider moving the detailed storage format specification (the directory tree and file-level details) into a separate ARCHITECTURE.md reference within the bundle, keeping only a brief summary inline.

Dimension	Reasoning	Score
Conciseness	The opening paragraphs over-explain what DSP is and why it exists — Claude doesn't need to be told that 'LLM coding agents lose context between tasks.' The core concepts section explains graph theory basics unnecessarily. However, the command tables and workflow rules are efficient. Overall, there's meaningful content but noticeable padding that could be trimmed by ~30%.	3 / 5
Actionability	Provides concrete, executable CLI commands with example outputs, a clear bootstrap workflow, and specific bash examples for common scenarios. Minor gaps: no example of full bootstrap DFS walkthrough on a real project, and the `create-function` syntax with `#` anchoring isn't fully explained. The commands are copy-paste ready but some edge cases are left implicit.	4 / 5
Workflow Clarity	The bootstrap workflow has a clear 5-step sequence, and the 'When to Update DSP' table provides an excellent decision matrix. The 'Workflow Rules' section gives a clear before/during/after pattern. However, there are no explicit validation checkpoints — no step says 'run detect-cycles or get-orphans to verify graph integrity after changes,' which is a gap for a system that modifies persistent state. Since DSP updates are additive/non-destructive to code, this doesn't trigger the destructive-operations cap at 3, but it's still a minor gap.	4 / 5
Progressive Disclosure	References to ARCHITECTURE.md, CLI source, and the article are clearly signaled at the end. The skill itself is well-structured with logical sections. However, no bundle files are provided, so the referenced paths point to external GitHub URLs rather than local bundle files. The content is somewhat long (~200 lines) and the full storage format specification could potentially live in a separate reference file, but it's not egregiously inlined.	4 / 5
	Total	15 / 20 Passed

Description

53%Scale 1-5

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 communicates a clear domain (codebase structural understanding for agents) with some concrete capabilities, but lacks an explicit 'Use when...' clause and relies on somewhat abstract language rather than concrete, actionable terms. The trigger terms are reasonable but miss common synonyms and natural user phrasings.

Suggestions

Add an explicit 'Use when...' clause with trigger scenarios, e.g., 'Use when an agent needs to understand code architecture, trace imports, find module dependencies, or map relationships between files without re-reading the entire repository.'

Replace abstract phrases like 'persistent structural memory' with more concrete actions, e.g., 'Builds and maintains a dependency graph, indexes public APIs and exports, and records the rationale behind module connections.'

Include natural trigger terms and synonyms users might use: 'code structure', 'imports', 'call graph', 'module relationships', 'architecture map', 'code navigation'.

Dimension	Reasoning	Score
Specificity	Names the domain (codebase structural memory) and lists a few actions ('navigate dependencies, track public APIs, understand why connections exist'), but these are somewhat abstract rather than concrete tool-level actions. Missing specifics like what formats, what outputs, or how it operates.	3 / 5
Completeness	The 'what' is reasonably clear (persistent structural memory, navigate dependencies, track APIs, understand connections), but there is no explicit 'when' clause. There's no 'Use when...' guidance, which per the rubric caps this dimension at 3.	3 / 5
Trigger Term Quality	Includes some relevant terms like 'dependencies', 'public APIs', 'codebase', and 'repo', but misses many natural user phrases like 'code structure', 'imports', 'call graph', 'architecture', 'module relationships', or 'code map'. The phrase 'persistent structural memory' is more jargon than natural language.	3 / 5
Distinctiveness Conflict Risk	The focus on 'persistent structural memory' and dependency navigation is fairly distinctive and unlikely to overlap with generic code editing or documentation skills. However, it could overlap with code analysis or architecture visualization skills. The 'agents' framing adds some distinctiveness.	4 / 5
	Total	13 / 20 Passed

Validation

90%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/data-structure-protocol/SKILL.md
Commit: fbdfd63

Reviewed: 2 days ago

Table of Contents

Discovery Implementation Validation

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.