rust-engineer

tessl i github:jeffallan/claude-skills --skill rust-engineer

Use when building Rust applications requiring memory safety, systems programming, or zero-cost abstractions. Invoke for ownership patterns, lifetimes, traits, async/await with tokio.

62%

Overall

Validation

Implementation

Activation

SKILL.md

Review

Evals

Validation

81%

Warnings & errors only

Criteria	Description	Result
metadata_version	'metadata' field is not a dictionary	Warning
license_field	'license' field is missing	Warning
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	13 / 16 Passed

Implementation

42%

This skill has strong progressive disclosure with a well-organized reference table, but critically lacks actionable code examples. The content is moderately verbose with persona descriptions Claude doesn't need, and the workflow lacks explicit validation checkpoints important for systems programming. The skill tells Claude what to do conceptually but doesn't show how with concrete, executable examples.

Suggestions

Add executable code examples for key patterns (e.g., a Result error handling snippet, a basic trait implementation, an async tokio example)

Remove or condense the 'Role Definition' section - Claude doesn't need persona descriptions to follow instructions

Add validation checkpoints to the workflow, such as 'Run cargo clippy --all-targets, fix warnings before proceeding' between implementation and testing steps

Include at least one complete, copy-paste ready example in the Output Templates section showing the expected format

Dimension	Reasoning	Score
Conciseness	Contains some unnecessary verbosity like the 'Role Definition' section explaining Claude's persona (which Claude doesn't need), and the 'When to Use This Skill' section largely duplicates the description. However, the constraints and reference table are reasonably efficient.	2 / 3
Actionability	No executable code examples anywhere. The skill describes what to do ('Design trait hierarchies', 'Handle errors') but provides no concrete code snippets, commands, or copy-paste ready examples. The 'Output Templates' section lists what to provide but doesn't show how.	1 / 3
Workflow Clarity	The 5-step 'Core Workflow' provides a sequence but lacks validation checkpoints or feedback loops. For a skill involving systems programming and unsafe code, there's no explicit validation step between implementation and testing, and no guidance on what to do when clippy or tests fail.	2 / 3
Progressive Disclosure	Excellent use of a reference table with clear 'Load When' conditions pointing to one-level-deep reference files. The main skill serves as an overview with well-signaled navigation to detailed topics like ownership, traits, async, etc.	3 / 3
	Total	8 / 12 Passed

Activation

72%

The description effectively identifies when to use the skill with good Rust-specific trigger terms, but fails to specify what concrete actions the skill performs. It reads more like a topic list than a capability description - users would know this is for Rust work, but not whether it helps write code, debug issues, explain concepts, or review implementations.

Suggestions

Add concrete actions at the beginning: 'Writes, debugs, and reviews Rust code with focus on...' or 'Implements and explains Rust patterns for...'

Clarify the skill's actual capabilities - does it generate code, explain concepts, review PRs, or all of these?

Dimension	Reasoning	Score
Specificity	Names the domain (Rust) and mentions specific concepts like 'ownership patterns, lifetimes, traits, async/await with tokio', but doesn't list concrete actions - it describes concepts rather than what the skill actually does (e.g., 'write', 'debug', 'refactor').	2 / 3
Completeness	Has a 'Use when' clause which is good, but the 'what' is weak - it describes when to invoke but not what concrete actions the skill performs. The description tells us the domain but not the capabilities (does it write code? review code? explain concepts?).	2 / 3
Trigger Term Quality	Good coverage of natural terms users would say: 'Rust', 'memory safety', 'systems programming', 'ownership', 'lifetimes', 'traits', 'async/await', 'tokio' - these are all terms Rust developers naturally use when seeking help.	3 / 3
Distinctiveness Conflict Risk	Clearly targets Rust specifically with distinct triggers like 'ownership patterns', 'lifetimes', 'tokio' that wouldn't overlap with other language skills. The Rust-specific terminology creates a clear niche.	3 / 3
	Total	10 / 12 Passed

Reviewed

14 days ago

Table of Contents

Validation Implementation Activation

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.