rust-async-patterns

Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.

Quality

44%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./plugins/AI-Agents-Safe-Coding-Skills/skills/rust-async-patterns/SKILL.md

The canonical home for this skill is rust-async-patterns in rmyndharis/antigravity-skills

Quality

Content

18%Scale 1-5

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

This skill is essentially a placeholder with no substantive content. It contains no Rust async code examples, no concrete patterns, no specific Tokio guidance, and no actionable workflow. All meaningful content is deferred to a resource file that doesn't exist in the bundle, making the skill non-functional.

Suggestions

Add concrete, executable Rust code examples showing core async patterns (e.g., spawning tasks with tokio::spawn, using channels, select!, error handling with anyhow/thiserror in async contexts).

Replace the generic instruction bullets with a specific workflow for building async Rust code, including compilation checks and common pitfall avoidance steps.

Either provide the referenced `resources/implementation-playbook.md` bundle file or inline the essential patterns directly in the SKILL.md so the skill is self-contained enough to be useful.

Remove boilerplate sections like 'Do not use this skill when - The task is unrelated to rust async patterns' which add no value.

Dimension	Reasoning	Score
Conciseness	The 'Use this skill when' and 'Do not use this skill when' sections are somewhat boilerplate and add little value. The instructions section is generic filler ('Clarify goals, constraints, and required inputs') that doesn't convey Rust async-specific knowledge. However, it's not excessively verbose overall.	3 / 5
Actionability	There is zero concrete code, no executable examples, no specific commands, and no Rust async patterns actually shown. The instructions are entirely vague platitudes like 'Apply relevant best practices and validate outcomes.' Everything actionable is deferred to a resource file that isn't provided.	1 / 5
Workflow Clarity	There is no workflow, no sequenced steps, no validation checkpoints. The four bullet points in Instructions are generic meta-instructions that could apply to any skill, not a clear process for async Rust development.	1 / 5
Progressive Disclosure	The skill references `resources/implementation-playbook.md` which is a reasonable attempt at progressive disclosure, but no bundle files are provided, so the reference is unverifiable. The SKILL.md itself contains essentially no substantive content to serve as an overview — it's an empty shell pointing to a missing file.	2 / 5
	Total	7 / 20 Passed

Description

70%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 adequately identifies its domain and includes a 'Use when' clause, making it functional for skill selection. However, it reads more like a topic list than a capability description—it says 'Master Rust async programming' (which uses imperative voice rather than third person descriptive) rather than describing concrete actions Claude can perform. Adding specific actions and a few more trigger terms would strengthen it.

Suggestions

Replace topic-area listing with concrete actions in third person, e.g., 'Implements async Rust code using Tokio, designs concurrent task pipelines, resolves async trait lifetime issues, and debugs runtime errors.'

Add more natural trigger terms and synonyms such as 'futures', 'spawn', 'await', 'runtime configuration', 'async/await', and 'parallelism' to improve keyword coverage.

Dimension	Reasoning	Score
Specificity	Names the domain (Rust async programming) and lists a few areas (Tokio, async traits, error handling, concurrent patterns), but these are more like topic areas than concrete actions. It doesn't describe specific actions like 'implement async streams', 'configure Tokio runtimes', or 'debug deadlocks'.	3 / 5
Completeness	Has both 'what' (Rust async programming with Tokio, async traits, error handling, concurrent patterns) and 'when' ('Use when building async Rust applications, implementing concurrent systems, or debugging async code'). The 'when' clause is present and reasonable but could be more specific with concrete trigger phrases.	4 / 5
Trigger Term Quality	Includes good natural keywords like 'Rust', 'async', 'Tokio', 'concurrent', 'async traits', and 'error handling' that users would naturally mention. Missing some variations like 'futures', 'spawn', 'await', 'runtime', '.rs', or 'parallelism'.	4 / 5
Distinctiveness Conflict Risk	Fairly distinct due to the specific combination of 'Rust' + 'async' + 'Tokio', which narrows the niche well. Minor overlap risk with a general Rust skill or a general async/concurrency skill, but the combination makes it mostly distinguishable.	4 / 5
	Total	15 / 20 Passed

Validation

90%

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 — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: plugins/AI-Agents-Safe-Coding-Skills/skills/rust-async-patterns/SKILL.md
Commit: 57c135b

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