CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

rust

Rust coding best practices for idiomatic, efficient, and maintainable code. Use when writing Rust code, reviewing code, or learning Rust patterns.

Quality

68%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./.claude/skills/rust/SKILL.md
SKILL.md
Quality
Evals
Security

Quality

Content

57%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 delivers concrete, actionable Rust guidance through well-chosen BAD/GOOD code contrasts and real cargo commands, which is its core strength. However, it is a monolithic catalog: much of it restates standard Rust idiom knowledge Claude already has, several examples are non-executable stubs, there is no ordered workflow or validation loop, and all ~380 lines are inlined with no progressive disclosure into reference files. Solid mid-range content with clear room to restructure.

Suggestions

Move domain-specific detail (async patterns, testing, documentation) into references/*.md files and keep SKILL.md as a lean overview with clearly signaled one-level-deep links, trimming the duplicated 'Code health' bullets.

Cut or compress sections that restate knowledge Claude already has (Cow, newtype, builder, iterator-vs-loop, with_capacity) and keep only project-specific prescriptions like the thiserror convention and the never-unwrap rule.

Complete the placeholder examples (replace "fn transfer(...) { ... }" bodies with minimal working code) and clarify the garbled fmt/clippy sequencing guidance into an explicit ordered workflow (write → cargo fmt → clippy → test).

DimensionReasoningScore

Conciseness

The body is mostly lean BAD/GOOD code pairs with almost no prose padding, but it contains redundancies ("Prefer smaller files, refactor large files into multi-file modules" followed by the near-duplicate "Refactor large modules into several") and several sections restating standard Rust idiom knowledge (Cow, newtype, builder pattern, iterators-over-loops, Vec::with_capacity) that Claude already knows. This lands between anchor 2 (several unnecessary/padded sections) and anchor 3 (mostly efficient with some tightening possible); the padding is sectional redundancy rather than explanatory verbosity, so 3 fits best.

3 / 5

Actionability

Most guidance is concrete and executable: BAD/GOOD code pairs, a copy-paste thiserror enum, and real commands like "cargo fmt -- --check && cargo clippy -- -D warnings && cargo test". It falls short of anchor 5 because a number of examples use "..." placeholder bodies (e.g., "fn process(data: String) { ... }", "pub(crate) fn internal_helper() { ... }", "fn transfer(from: AccountId, to: AccountId, amount: Amount) { ... }") making them non-executable snippets.

4 / 5

Workflow Clarity

The skill is a topic catalog with no multi-step sequence; the only validation checkpoint is the quality-gates line at the end, and the one sequencing instruction ("Write code that passes fmt/clippy first - Not after fixing") is garbled and ambiguous. This matches anchor 3 (checkpoints present but implicit/missing) rather than 4, which requires a clear sequence with most checkpoints present.

3 / 5

Progressive Disclosure

The clean ## section headers give the file real structure, but ~380 lines spanning eight domains (error handling, ownership, API design, async, testing, performance, modules, documentation) are all inlined in a single SKILL.md with no bundle files (no references/, scripts/, or assets/ exist) and no external references. This matches anchor 3 ("content that should be separate is inline") rather than 4, since nothing is split out or signaled as deeper material.

3 / 5

Total

13

/

20

Passed

Description

65%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 short, in third person, and has a genuine explicit 'Use when...' trigger clause with three natural usage scenarios, which is its main strength. Its weakness is the what-half: "best practices for idiomatic, efficient, and maintainable code" is a generic quality claim rather than a list of concrete capabilities, capping specificity. Overall a serviceable but under-specified description.

Suggestions

Replace the generic quality-attribute phrase with 2-3 concrete capabilities, e.g., "Apply idiomatic Rust patterns for error handling (thiserror), ownership/borrowing, async (tokio), and API design; enforce fmt/clippy quality gates."

Add common trigger synonyms users would actually say, such as "cargo", "clippy", "borrow checker", or "Rust idioms", to broaden natural-term coverage.

Qualify the trigger "reviewing code" as "reviewing Rust code" to reduce overlap with generic code-review skills.

DimensionReasoningScore

Specificity

"Rust coding best practices for idiomatic, efficient, and maintainable code" names the domain clearly, but the stated capabilities are generic quality attributes rather than concrete actions, matching the anchor "names the domain but actions are minimal or generic". It is above 1 because the domain and focus (Rust) are explicit, but below 3 because no concrete action (e.g., "extract text", "fill forms") is ever listed.

2 / 5

Completeness

Both parts are present: the what ("Rust coding best practices for idiomatic, efficient, and maintainable code") and an explicit when ("Use when writing Rust code, reviewing code, or learning Rust patterns"). It does not reach 5 because the what is generic ("best practices") rather than the concrete capability list the top anchor requires.

4 / 5

Trigger Term Quality

"writing Rust code", "reviewing code", and "learning Rust patterns" are natural phrases a user would say, giving good keyword coverage across usage scenarios. It falls short of 5 because common variations like "cargo", "clippy", "borrow checker", or "Rust idioms" are absent, but sits above 3 because the three trigger scenarios are directly covered.

4 / 5

Distinctiveness Conflict Risk

"Rust coding best practices" carves out a clear niche with distinct triggers, but the unqualified phrase "reviewing code" in the trigger clause creates minor overlap risk with generic code-review skills. This matches "mostly distinct; minor overlap risk with closely related skills" rather than the minimal-conflict anchor at 5.

4 / 5

Total

14

/

20

Passed

Validation

93%

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

CriteriaDescriptionResult

allowed_tools_field

'allowed-tools' contains unusual tool name(s)

Warning

Total

15

/

16

Passed

Repository

pgdogdev/pgdog

Path

.claude/skills/rust/SKILL.md

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.