rust-engineer

Writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions. Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling with Result/Option. Use when building Rust applications, solving ownership or borrowing issues, designing trait-based APIs, implementing async/await concurrency, creating FFI bindings, or optimizing for performance and memory safety. Invoke for Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming.

Quality

89%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Failed to scan

The risk profile of this skill

Quality

Content

78%Weight 40%Scale 1-5

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

The body is well-structured and actionable, with executable examples, a sequenced workflow including a validation checkpoint, and clean progressive disclosure to five reference files. It loses a little on conciseness and actionability due to minor redundancy and a few illustrative-only snippets.

Suggestions

Trim the trailing Knowledge Reference keyword list and obvious inline comments (e.g. '// borrow lives as long as the input slice') to tighten conciseness toward the top anchor.

Replace illustrative-only snippets with fully self-contained examples—e.g. make the tokio::join! sample use returned values so it runs and demonstrates the pattern end-to-end.

Add an explicit validate→fix→retry loop in the Core Workflow (e.g. 'If clippy/fmt/test fail, fix and re-run before finalising') to strengthen workflow_clarity's feedback-loop check.

Dimension	Reasoning	Score
Conciseness	The body is largely lean with terse commented code examples, but contains minor over-explanation (e.g. the trailing Knowledge Reference keyword dump and explanatory comments like 'borrow lives as long as the input slice') that could be trimmed, placing it just below the top anchor.	4 / 5
Actionability	Provides concrete, mostly copy-paste-ready Rust snippets for ownership, traits, thiserror, and tokio plus exact cargo validation commands, with only minor gaps such as illustrative fragments (the tokio::join! on sleeps discarding values).	4 / 5
Workflow Clarity	The Core Workflow is a clear five-step sequence with an explicit 'Validate' step (clippy, fmt --check, test; fix all warnings before finalising), but lacks a full validate→fix→retry feedback loop and checklists, leaving minor validation gaps.	4 / 5
Progressive Disclosure	A Reference Guide table signals five real, one-level-deep reference files (all present: ownership, traits, error-handling, async, testing) with 'Load When' triggers, keeping the overview in SKILL.md and bulk detail in references.	5 / 5
	Total	17 / 20 Passed

Description

100%Weight 40%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 is exemplary: it pairs a comprehensive, concrete list of capabilities with explicit 'Use when' and 'Invoke for' trigger guidance and a tightly scoped Rust niche. It hits the top anchor on all four dimensions.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions—'Writes, reviews, and debugs idiomatic Rust code', 'Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling'—with comprehensive coverage of the skill's capabilities.	5 / 5
Completeness	Explicitly answers both 'what' (writes/reviews/debugs Rust code with the listed actions) and 'when' via concrete 'Use when...' and 'Invoke for...' trigger phrases, satisfying the top anchor.	5 / 5
Trigger Term Quality	Comprehensive natural trigger terms plus synonyms and tool names appear in both the 'Use when...' and 'Invoke for...' clauses: Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming.	5 / 5
Distinctiveness Conflict Risk	Occupies a clear Rust-specific niche with distinct triggers (Cargo, tokio, lifetimes, ownership, FFI bindings) and minimal overlap risk with unrelated skills.	5 / 5
	Total	20 / 20 Passed

Validation

100%

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

Validation for skill structure

No warnings or errors.

Repository: Jeffallan/claude-skills
Path: skills/rust-engineer/SKILL.md
Commit: 882ef55

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