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

56%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./plugins/systems-programming/skills/rust-async-patterns/SKILL.md

Quality

Content

29%

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

This skill provides a basic scaffolding for async Rust with Tokio but falls short on substance. The core value—actual async patterns like select!, channels, JoinSet, error handling strategies—is either reduced to bullet-point mentions or deferred to a non-existent reference file. The content that is present includes unnecessary conceptual explanations that Claude already knows, while lacking the concrete, executable pattern examples that would make this skill genuinely useful.

Suggestions

Either provide the referenced 'references/details.md' file with detailed patterns, or inline the most critical patterns (select!, channels, JoinSet, error handling) as executable code examples directly in SKILL.md.

Remove the conceptual table explaining Future/async fn/await and the ASCII execution model diagram—Claude already understands these concepts. Use the reclaimed space for concrete pattern examples.

Add a workflow section for debugging async code (e.g., steps to diagnose deadlocks, identify blocking calls, use tracing spans) with specific commands and validation checkpoints.

Replace the 'When to Use This Skill' section with actionable decision criteria, or remove it entirely to save tokens.

Dimension	Reasoning	Score
Conciseness	The skill includes some unnecessary content like the 'When to Use This Skill' bullet list and the conceptual table explaining what Future, async fn, and await are—concepts Claude already knows well. The ASCII diagram of the execution model is borderline. However, the code examples and best practices sections are reasonably tight.	2 / 3
Actionability	The quick start provides executable code with proper Cargo.toml dependencies, which is good. However, the actual patterns (select!, channels, JoinSet, CancellationToken, semaphores) are only mentioned as bullet points in best practices without any concrete code examples. The real substance is deferred to 'references/details.md' which doesn't exist in the bundle.	2 / 3
Workflow Clarity	There is no multi-step workflow, no sequenced process for building async applications, and no validation or debugging checkpoints. The skill is essentially a reference card with a basic example and a list of tips, with no guidance on how to approach building or debugging async systems step by step.	1 / 3
Progressive Disclosure	The skill references 'references/details.md' for detailed patterns, but this file is not provided in the bundle, making the reference a dead link. The main content is a mix of conceptual overview and a single basic example, with the most valuable content (actual patterns) entirely absent. This is effectively a broken progressive disclosure structure.	1 / 3
	Total	6 / 12 Passed

Description

82%

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 reasonably well-structured with a clear 'Use when' clause and good trigger terms for the Rust async ecosystem. Its main weakness is that the capabilities are described at a topic/category level rather than as concrete actions, and the word 'Master' at the beginning is somewhat vague. It would benefit from listing specific actionable capabilities rather than broad topic areas.

Suggestions

Replace topic-level descriptions with concrete actions, e.g., 'Implements Tokio-based async runtimes, writes async trait implementations, handles Pin/Unpin constraints, debugs deadlocks in concurrent tasks' instead of listing broad categories.

Rephrase the opening to use third-person active voice describing actions rather than starting with 'Master', e.g., 'Guides development of Rust async applications using Tokio...'

Dimension	Reasoning	Score
Specificity	Names the domain (Rust async programming) and lists some areas (Tokio, async traits, error handling, concurrent patterns), but these are more like topic categories than concrete actions. It doesn't list specific actions like 'implement async streams', 'configure Tokio runtime', or 'convert sync code to async'.	2 / 3
Completeness	Clearly answers both what ('Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns') and when ('Use when building async Rust applications, implementing concurrent systems, or debugging async code') with an explicit 'Use when' clause.	3 / 3
Trigger Term Quality	Includes strong natural keywords users would say: 'Rust', 'async', 'Tokio', 'async traits', 'concurrent', 'error handling', 'async code'. These are terms developers naturally use when seeking help with async Rust programming.	3 / 3
Distinctiveness Conflict Risk	While 'Rust async' and 'Tokio' are fairly specific, there could be overlap with a general Rust programming skill or a general async/concurrency skill. The combination of Rust + async + Tokio helps, but 'error handling' and 'concurrent patterns' are broad enough to potentially conflict with other skills.	2 / 3
	Total	10 / 12 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 — 11 / 11 Passed

Validation for skill structure

No warnings or errors.

Repository: wshobson/agents
Commit: cf6059d

Reviewed: 1 day 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.