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.
72
88%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
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.
This is an excellent skill description that thoroughly covers specific Rust capabilities, provides explicit trigger guidance with a 'Use when' clause, and includes a comprehensive list of natural trigger terms. The description is well-structured with clear what/when/invoke sections and uses appropriately specific Rust ecosystem terminology that makes it highly distinctive.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: writes/reviews/debugs Rust code, implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, structures error handling with Result/Option. | 3 / 3 |
Completeness | Clearly answers both 'what' (writes, reviews, debugs Rust code with specific patterns) and 'when' (explicit 'Use when' clause covering building Rust apps, ownership issues, trait APIs, async concurrency, FFI, performance optimization). Also includes an 'Invoke for' keyword list. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural terms users would say: Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming, FFI bindings, trait-based APIs. These are terms Rust developers naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with Rust-specific terminology (ownership, borrowing, lifetimes, tokio, Cargo, zero-cost abstractions) that clearly separates it from general programming or other language-specific skills. Very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 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 well-structured Rust skill with strong actionability through executable code examples and clear validation workflows. Its main weaknesses are moderate verbosity (persona description, redundant knowledge reference, some obvious constraints) and the absence of the referenced bundle files that the progressive disclosure table points to. The core content is solid and would effectively guide Claude in writing idiomatic Rust.
Suggestions
Remove the persona description opening paragraph and the Knowledge Reference section — they add no actionable value beyond what the rest of the content already conveys.
Provide the referenced files (references/ownership.md, references/traits.md, etc.) or remove the reference table to avoid pointing to non-existent resources.
Trim MUST NOT DO items that Claude inherently knows (e.g., 'Create memory leaks or dangling pointers') and focus constraints on project-specific or non-obvious rules.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Generally efficient but includes some unnecessary framing ('Senior Rust engineer with deep expertise...'), the Knowledge Reference section is redundant with the rest of the content, and some constraints restate things Claude already knows (e.g., 'don't create memory leaks or dangling pointers'). The Output Templates section is somewhat generic. However, the code examples are tight and the reference table is well-structured. | 2 / 3 |
Actionability | Provides fully executable, copy-paste-ready Rust code examples for all major patterns (lifetimes, traits, error handling, async). Validation commands are concrete and complete. The MUST DO/MUST NOT DO constraints give specific, actionable guidance. | 3 / 3 |
Workflow Clarity | The Core Workflow provides a clear 5-step sequence with an explicit validation step (step 5) that includes specific commands. The validation commands section reinforces this. The workflow includes the important feedback loop of 'fix all warnings before finalising' in the validation step. | 3 / 3 |
Progressive Disclosure | The reference table elegantly points to 5 topic-specific files with clear 'Load When' triggers, which is excellent design. However, no bundle files are provided, meaning none of those referenced files actually exist. The main SKILL.md also inlines substantial content (code examples, constraints) that could arguably live in the referenced files, creating some redundancy if those files were populated. | 2 / 3 |
Total | 10 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- jeffallan/claude-skills
- Commit
e8be415
- Reviewed
Table of Contents
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.