heap-snapshot-analysis

Analyze V8 heap snapshots to investigate memory leaks and retention issues. Use when given .heapsnapshot files, asked to compare before/after snapshots, asked to find what retains objects, or investigating why objects survive GC. Provides snapshot parsing, comparison, retainer-path helpers, and scratchpad scripts.

Quality

96%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Quality

Content

92%

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

The body is a dense, highly actionable, well-sequenced guide built on specialized V8/VS Code knowledge with concrete executable code and real error-recovery guidance. Its main weakness is progressive disclosure: referenced helper files and the scratchpad directory are absent from the bundle, and a large body of reference material is inlined instead of being split into linked reference files.

Suggestions

Create the referenced bundle files (helpers/parseSnapshot.ts, compareSnapshots.ts, findRetainers.ts, streamSnapshot.mjs) and a scratchpad/ directory so the linked references actually resolve — none currently exist in the bundle.

Move the inline reference material (Common VS Code Retention Patterns, False Retainers to Watch For, V8 Heap Snapshot Format) into separate reference files and link to them from SKILL.md, keeping the overview lean and pointing one level deep.

Add explicit validation/verification checkpoints to the workflow (e.g., sanity-check parsed node counts or confirm retainer paths against the edge-type rules before reporting) to strengthen the feedback loop.

Dimension	Reasoning	Score
Conciseness	The body is dense with specialized V8/VS Code heap-analysis knowledge (snapshot tuple widths, edge-type semantics, specific retention patterns) that Claude would not already know, and avoids explaining generic concepts; it does not reach the padded/verbose level 1, though the intro slightly overlaps the 'When to Use' section.	3 / 3
Actionability	Provides copy-paste-ready executable TypeScript imports, a bash invocation with concrete flags ('node --max-old-space-size=24576 scratchpad/…/findOffsets.mjs /path/to/Heap.heapsnapshot'), and specific function calls with real arguments ('findRetainerPaths(graph, "ChatModel", { maxPaths: 5, maxDepth: 25, maxAttempts: 200 })'), matching the fully-executable anchor.	3 / 3
Workflow Clarity	A clear numbered sequence (1. Parse, 2. Compare, 3. Find Retainers, 4. Write Scripts) with explicit error-recovery guidance for the fragile >2 GiB case ('can fail with ERR_FS_FILE_TOO_LARGE… Switch to a streaming script'); the destructive/batch validation cap does not bind since heap analysis is read-only, so it is above the gaps-present level 2.	3 / 3
Progressive Disclosure	References are clearly signaled and one-level-deep (not the nested/monolithic level 1), but the linked bundle files (helpers/parseSnapshot.ts, compareSnapshots.ts, findRetainers.ts, streamSnapshot.mjs) and the scratchpad/ directory do not exist in the bundle, and substantial reference-style content (Common VS Code Retention Patterns, V8 Heap Snapshot Format, False Retainers) is inlined rather than split into reference files — falling short of the well-organized-with-resolved-references level 3.	2 / 3
	Total	11 / 12 Passed

Description

100%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong, third-person description that names concrete capabilities, includes an explicit 'Use when…' trigger clause with natural keywords, and occupies a distinct niche unlikely to collide with other skills. It is concise and avoids over-claims or fluff.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions — 'Analyze V8 heap snapshots', 'investigate memory leaks and retention issues', 'compare before/after snapshots', 'find what retains objects', plus 'Provides snapshot parsing, comparison, retainer-path helpers, and scratchpad scripts' — matching the multiple-specific-actions anchor rather than the names-domain-only level 2.	3 / 3
Completeness	Explicitly answers both what ('Analyze V8 heap snapshots…Provides snapshot parsing, comparison, retainer-path helpers') and when via an explicit 'Use when given .heapsnapshot files, asked to compare before/after snapshots…' clause, so it is not capped at 2 for a missing trigger.	3 / 3
Trigger Term Quality	Natural terms a user would say are well covered: '.heapsnapshot files', 'memory leaks', 'compare before/after snapshots', 'what retains objects', 'objects survive GC', 'retainer'; not jargon-only (which would be level 1) nor missing common variations (level 2).	3 / 3
Distinctiveness Conflict Risk	Tightly scoped to 'V8 heap snapshots' / '.heapsnapshot files' with distinct, niche-specific triggers, making overlap with other skills unlikely; not the generic 'works with files' level 2 or 'helps with code and documents' level 1.	3 / 3
	Total	12 / 12 Passed

Validation

93%

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 — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
relative_links	Relative link issues: 5 missing	Warning

	Total	15 / 16 Passed

Repository: posit-dev/positron
Path: .github/skills/heap-snapshot-analysis/SKILL.md
Commit: b87c504

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.