rust-patterns

Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications.

Quality

—

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Quality

Content

65%

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

The content is a strong, actionable Rust idioms reference with rich executable good/bad examples, but it is verbose and monolithic, repeating some anti-patterns and embedding large topic blocks inline. Splitting major areas into reference files and trimming redundant prose would improve conciseness and progressive disclosure.

Suggestions

Move large topic groups (e.g. Concurrency, Error Handling, Module System) into separate reference files linked from SKILL.md to improve progressive disclosure at this length.

Remove the standalone 'Anti-Patterns to Avoid' section or fold it into each section, since the inline Bad examples already cover the same ground.

Trim explanatory sentences about concepts Claude already knows (e.g. 'Rust's ownership system prevents data races...') to tighten token efficiency.

Dimension	Reasoning	Score
Conciseness	The body is mostly lean good/bad code contrasts, but it includes concepts Claude already knows ("Rust's ownership system prevents data races and memory bugs at compile time") and redundancy between inline Bad examples and the separate 'Anti-Patterns to Avoid' section. Not level 3 because of this repetition and explanatory prose, and not level 1 because most lines are useful executable patterns rather than padded explanation.	2 / 3
Actionability	It provides numerous concrete, executable Rust snippets with good/bad contrasts and copy-paste-ready idioms (e.g. the `Arc<Mutex<T>>` and `thiserror`/`anyhow` examples). Not level 2 because the guidance is complete and executable rather than pseudocode, fully meeting the top anchor.	3 / 3
Workflow Clarity	This is a patterns reference rather than a multi-step workflow, so sections exist but there is no sequenced process with validation checkpoints. Not level 3 because no explicit validate->fix->retry feedback loops are shown, and not level 1 because the 'When to Use' list and sectioned structure give reasonable order rather than being unclear.	2 / 3
Progressive Disclosure	The skill is a single monolithic ~500-line file with no references/scripts/assets bundle, so large topic groups (concurrency, error handling) that could be split into separate reference files are inline. Not level 3 because at this length it exceeds the 'under 50 lines' exception and is not split into one-level-deep references, and not level 1 because sections are clearly organized rather than a disorganized wall of text.	2 / 3
	Total	9 / 12 Passed

Description

57%

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 is third-person and clearly scoped to Rust, but it enumerates topic areas rather than concrete actions and omits any explicit "Use when..." trigger. Adding a trigger clause and concrete verbs would lift specificity and completeness toward the top level.

Suggestions

Add a 'Use when...' clause naming natural triggers (e.g. writing, reviewing, or refactoring Rust code, or designing crate/module structure).

Lead with concrete verbs/actions (e.g. 'Apply idiomatic ownership, propagate errors with ?, model states as enums') instead of listing topic nouns.

Include common natural phrasings users say ('Rust code', 'Rust review', 'borrow checker issues') to improve trigger-term coverage.

Dimension	Reasoning	Score
Specificity	The description names a domain and several areas ("ownership, error handling, traits, concurrency") but lists topics rather than the multiple concrete actions a score-3 example requires (e.g. "Extract text... fill forms, merge documents"). It is not level 1 because the Rust domain is named with specific sub-areas rather than being abstractly vague.	2 / 3
Completeness	It clearly answers "what" (idiomatic Rust patterns and best practices) but provides no explicit "when"/trigger guidance, which per the rubric caps completeness at 2. Not level 3 because there is no "Use when..." clause, and not level 1 because the "what" is concrete.	2 / 3
Trigger Term Quality	It contains relevant Rust keywords a user might say ("Rust patterns", "ownership", "error handling") but lacks common natural variations and an explicit trigger phrase. Not level 3 because there is no "Use when..." coverage of how users actually request this, and not level 1 because the terms are domain-relevant rather than generic jargon.	2 / 3
Distinctiveness Conflict Risk	The Rust-specific framing ("Idiomatic Rust patterns", ownership, traits) carves a clear niche unlikely to trigger for non-Rust skills. Not level 2 because it is far more specific than "Works with document files", and the distinct triggers make conflict unlikely.	3 / 3
	Total	9 / 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
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	15 / 16 Passed

Repository: affaan-m/ECC
Commit: 4130457

Reviewed: 1 day 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.