tdg-personal/rust-patterns
Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications.
63
63%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
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 identifies the Rust domain and lists relevant conceptual areas but reads more like a course syllabus than an actionable skill description. It lacks concrete actions (verbs describing what the skill does), has no 'Use when...' clause for trigger guidance, and misses several natural keywords users would employ when seeking Rust help.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user is writing Rust code, debugging borrow checker errors, implementing traits, or working with .rs files.'
Replace topic listings with concrete actions, e.g., 'Guides implementation of idiomatic Rust patterns, resolves ownership and lifetime issues, designs error handling with Result/Option, and structures async/concurrent code.'
Include additional natural trigger terms users would say: 'borrow checker', 'lifetimes', 'cargo', 'crate', '.rs', 'async/await', 'Result', 'Option', 'unsafe'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Rust) and lists several topic areas (ownership, error handling, traits, concurrency), but these are conceptual categories rather than concrete actions. It doesn't describe specific actions like 'implement trait bounds', 'refactor unsafe code', or 'write async handlers'. | 2 / 3 |
Completeness | Describes what the skill covers (Rust patterns and concepts) but completely lacks any 'Use when...' clause or explicit trigger guidance. Per the rubric, a missing 'Use when...' clause should cap completeness at 2, and since the 'what' is also somewhat vague (listing topics rather than actions), this scores a 1. | 1 / 3 |
Trigger Term Quality | Includes relevant Rust-specific keywords like 'ownership', 'traits', 'concurrency', and 'error handling' that users might mention. However, it misses common variations and natural phrases users would say such as 'borrow checker', 'lifetimes', 'Result/Option', 'async/await', 'cargo', or '.rs files'. | 2 / 3 |
Distinctiveness Conflict Risk | The mention of 'Rust' and Rust-specific concepts like 'ownership' and 'traits' provides some distinctiveness, but the broad framing ('best practices for building safe, performant applications') could overlap with general programming or systems programming skills. | 2 / 3 |
Total | 7 / 12 Passed |
Implementation
77%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid Rust patterns reference with excellent actionability — nearly every concept is illustrated with executable, idiomatic code examples showing both good and bad patterns. The main weaknesses are moderate verbosity (some explanatory prose Claude doesn't need) and the monolithic structure that could benefit from progressive disclosure via linked sub-files for advanced topics like async/concurrency or unsafe code.
Suggestions
Remove explanatory prose Claude already knows (e.g., 'Rust's ownership system prevents data races...', the 'How It Works' summary paragraph) to improve conciseness.
Consider splitting into sub-files (e.g., CONCURRENCY.md, ERROR_HANDLING.md) with brief summaries and links in the main SKILL.md to improve progressive disclosure for this lengthy reference.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is fairly comprehensive but includes some explanatory text Claude already knows (e.g., 'Rust's ownership system prevents data races and memory bugs at compile time'). The 'How It Works' section is a verbose summary that restates what the content itself demonstrates. However, most sections are reasonably lean with code examples doing the heavy lifting. | 2 / 3 |
Actionability | Every section provides fully executable, copy-paste-ready Rust code examples with clear good/bad comparisons. Commands in the tooling section are concrete and specific. The code examples are complete and idiomatic, not pseudocode. | 3 / 3 |
Workflow Clarity | This is a pattern/reference skill rather than a multi-step workflow skill. For its purpose, the content is clearly organized with unambiguous guidance per topic. The tooling section provides clear command sequences. No destructive or batch operations require validation checkpoints. | 3 / 3 |
Progressive Disclosure | The content is a single monolithic file at ~300+ lines covering many topics. While well-organized with headers, the depth of coverage (ownership, errors, enums, traits, concurrency, unsafe, modules, tooling) could benefit from splitting into referenced sub-files. No external references are provided for deeper dives into any topic. | 2 / 3 |
Total | 10 / 12 Passed |
Validation
90%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 | |
Reviewed
Table of Contents