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.
60
70%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/systems-programming/skills/rust-async-patterns/SKILL.mdQuality
Discovery
75%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 has good structure with an explicit 'Use when' clause and targets a clear niche (Rust async/Tokio). Its main weakness is that the capabilities listed are more like topic categories than concrete actions, and the trigger terms could include more natural variations that users would search for. The word 'Master' at the beginning is slightly vague/aspirational rather than action-oriented.
Suggestions
Replace topic-level terms with concrete actions, e.g., 'Implements async functions with Tokio, configures runtimes, writes async trait implementations, handles errors across await boundaries, and structures concurrent task spawning.'
Add more natural trigger terms and file/concept variations such as 'futures', 'async/await', '.await', 'tokio::spawn', 'select!', 'join!', 'runtime configuration', 'async streams'.
| 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 areas 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, 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 relevant keywords like 'Rust', 'async', 'Tokio', 'concurrent', and 'async traits', which users would naturally mention. However, it misses common variations like 'futures', 'spawn', 'await', '.await', 'runtime', 'tokio::spawn', 'async/await', or 'parallelism'. | 2 / 3 |
Distinctiveness Conflict Risk | The combination of 'Rust' + 'async' + 'Tokio' creates a very specific niche that is unlikely to conflict with other skills. It's clearly distinguishable from general Rust skills or general async programming skills in other languages. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a comprehensive async Rust reference with excellent, executable code examples covering the most important Tokio patterns. Its main weaknesses are verbosity from including conceptual explanations Claude doesn't need (execution model, abstractions table) and a monolithic structure that would benefit from splitting advanced patterns into separate files. The debugging and workflow guidance could be more structured with explicit validation steps.
Suggestions
Remove the 'Core Concepts' section (execution model diagram and key abstractions table) — Claude already understands these fundamentals, saving ~20 lines of token budget.
Split advanced patterns (Resource Management, Async Traits, Streams) into separate referenced files to improve progressive disclosure and reduce the main file's length.
Add a structured debugging workflow with explicit steps: e.g., '1. Check for blocking calls with tokio-console → 2. Verify Send bounds on spawned futures → 3. Check for locks held across .await points'.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary content Claude already knows (the async execution model diagram, the key abstractions table explaining what Future/await/Task are, and the 'When to Use This Skill' section). However, the code examples themselves are lean and well-structured. The Do's/Don'ts section is efficient. Overall mostly efficient but could be tightened by removing conceptual explanations. | 2 / 3 |
Actionability | The skill provides fully executable, copy-paste ready Rust code examples for every pattern. Dependencies are specified in Cargo.toml, concrete patterns cover JoinSet, channels (mpsc/broadcast/oneshot/watch), error handling with thiserror/anyhow, graceful shutdown, async traits, streams, and resource management. Each pattern is immediately usable. | 3 / 3 |
Workflow Clarity | The patterns are clearly presented as individual, well-labeled sections with good code examples. However, there are no explicit validation checkpoints, no sequencing guidance for how patterns compose together, and no feedback loops for debugging when things go wrong. The debugging section is brief and lacks a structured troubleshooting workflow. | 2 / 3 |
Progressive Disclosure | The content is a monolithic file with all patterns inline. At ~350+ lines, several patterns (like the full Repository implementation or the connection pool) could be split into referenced files. There are no references to external files for advanced topics. The section headers provide some organization, but the sheer volume of inline content makes it harder to navigate. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
90%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 |
|---|---|---|
skill_md_line_count | SKILL.md is long (514 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- wshobson/agents
- Commit
34632bc
- 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.