m02-resource

CRITICAL: Use for smart pointers and resource management. Triggers: Box, Rc, Arc, Weak, RefCell, Cell, smart pointer, heap allocation, reference counting, RAII, Drop, should I use Box or Rc, when to use Arc vs Rc, 智能指针, 引用计数, 堆分配

Quality

53%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/m02-resource/SKILL.md

Quality

Content

35%

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

This skill serves as a conceptual decision guide for Rust smart pointer selection, with good structural organization through tables and flowcharts. Its main weakness is the complete absence of executable code examples—critical for a programming skill about concrete types like Box, Rc, Arc, and RefCell. There is also significant redundancy across sections that cover similar decision logic in different formats.

Suggestions

Add concrete, executable Rust code examples for each smart pointer type (e.g., Box for recursive types, Rc<RefCell<T>> for shared mutable state, Arc<Mutex<T>> for thread-safe sharing)

Consolidate overlapping sections—the 'Trace Down', 'Quick Reference', 'Decision Flowchart', and 'Thinking Prompt' sections all cover similar selection logic and could be merged into one authoritative decision guide

Add a practical before/after code example showing a common refactoring scenario (e.g., converting Rc cycles to use Weak, or replacing Arc with Rc when single-threaded)

Dimension	Reasoning	Score
Conciseness	The content is reasonably efficient but includes some redundancy—the decision flowchart, quick reference table, trace down section, and common errors/anti-patterns tables overlap significantly in the guidance they provide. The 'Error → Design Question' table and 'Thinking Prompt' section also partially duplicate each other. However, it avoids explaining basic concepts Claude already knows.	2 / 3
Actionability	The skill provides conceptual decision frameworks and tables but no executable code examples whatsoever. For a skill about smart pointers and resource management in Rust, there are no concrete code snippets showing actual usage patterns, type declarations, or implementations—only type names and abstract descriptions.	1 / 3
Workflow Clarity	The decision flowchart and thinking prompt provide a clear sequence for choosing the right smart pointer, which is the core workflow. However, there are no validation checkpoints or feedback loops—e.g., no guidance on how to verify the choice was correct, how to detect misuse at compile time, or what to do when refactoring from one pointer type to another.	2 / 3
Progressive Disclosure	The skill references related skills (m01-ownership, m03-mutability, m07-concurrency, m12-lifecycle) which is good for navigation, but no bundle files exist to support these references. The content itself is somewhat monolithic with many overlapping tables that could be consolidated or split into separate reference files.	2 / 3
	Total	7 / 12 Passed

Description

72%

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 excels at trigger term coverage with an impressive range of specific Rust types, natural user questions, and multilingual terms. However, it lacks concrete action verbs describing what the skill actually does (e.g., explains, compares, implements) and would benefit from a more explicit 'Use when...' clause describing usage scenarios beyond just listing trigger keywords.

Suggestions

Add concrete action verbs describing what the skill does, e.g., 'Explains trade-offs between smart pointer types, helps choose the right pointer for ownership patterns, implements RAII and Drop traits'

Add an explicit 'Use when...' clause, e.g., 'Use when the user asks about Rust ownership with heap-allocated data, choosing between smart pointer types, or implementing custom Drop behavior'

Dimension	Reasoning	Score
Specificity	The description names the domain ('smart pointers and resource management') and lists specific types (Box, Rc, Arc, etc.), but doesn't describe concrete actions like 'explains trade-offs', 'helps choose between', or 'implements RAII patterns'. It tells you what it covers but not what it does with those topics.	2 / 3
Completeness	The 'when' is partially addressed via the 'CRITICAL: Use for' prefix and the 'Triggers:' list, but there is no explicit 'Use when...' clause describing scenarios. The 'what' is weak — it says 'smart pointers and resource management' but doesn't specify what actions the skill performs (e.g., explaining, implementing, comparing).	2 / 3
Trigger Term Quality	Excellent coverage of natural trigger terms including specific Rust types (Box, Rc, Arc, Weak, RefCell, Cell), conceptual terms (smart pointer, heap allocation, reference counting, RAII, Drop), natural user questions ('should I use Box or Rc', 'when to use Arc vs Rc'), and even multilingual triggers (智能指针, 引用计数, 堆分配).	3 / 3
Distinctiveness Conflict Risk	The description is highly specific to Rust smart pointers and resource management with very distinct trigger terms (Box, Rc, Arc, RefCell, RAII, Drop). This is unlikely to conflict with other skills unless there are multiple Rust-specific skills, and even then the niche is well-defined.	3 / 3
	Total	10 / 12 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: actionbook/rust-skills
Commit: fa60f79

Reviewed: 29 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.