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.
72
66%
Does it follow best practices?
Impact
Pending
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 with 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. Overall it's a solid but not exceptional description.
Suggestions
Replace topic-area language with specific concrete actions, e.g., 'Implements async functions with Tokio runtime, converts sync code to async, manages task spawning and cancellation, handles async error propagation'.
Expand trigger terms to include common variations users would naturally say: 'futures', 'async/await', 'runtime', 'spawn', 'tokio::main', '.await', 'parallelism in Rust'.
| 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 might naturally say. However, it misses common variations like 'futures', 'spawn', 'await', '.await', 'runtime', 'async/await', 'tokio::spawn', 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
57%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill excels at actionability with comprehensive, executable Rust async code examples covering the major Tokio patterns. However, it suffers from being a monolithic wall of content that would benefit from progressive disclosure, includes some unnecessary conceptual explanations Claude already knows (Future/async/await definitions), and lacks explicit workflow validation steps for the more complex patterns like graceful shutdown and resource management.
Suggestions
Split the 7 patterns into separate referenced files (e.g., CHANNELS.md, SHUTDOWN.md, STREAMS.md) and keep SKILL.md as a concise overview with links to each pattern.
Remove the 'Core Concepts' section (Key Abstractions table and execution model diagram)—Claude already understands Futures, async/await, and runtimes.
Add validation/verification steps to complex patterns like graceful shutdown (e.g., 'Verify all tasks completed by checking JoinSet is empty') and resource management (e.g., 'Assert pool connections are returned').
Remove the 'When to Use This Skill' section—this is metadata that belongs in frontmatter, not in the body content.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary content like the 'When to Use This Skill' section and the 'Core Concepts' table explaining what Future, async fn, and await are—concepts Claude already knows well. The code examples themselves are lean, but the overall document is quite long with patterns that could be more tightly presented. | 2 / 3 |
Actionability | The skill provides fully executable, copy-paste ready Rust code examples across all patterns—JoinSet, channels (mpsc/broadcast/oneshot/watch), error handling with thiserror/anyhow, graceful shutdown, async traits, streams, and resource management. Cargo.toml dependencies are included. Very concrete and specific. | 3 / 3 |
Workflow Clarity | The patterns are well-organized and individually clear, but there's no sequenced multi-step workflow with validation checkpoints. For a skill covering complex async patterns including resource management and graceful shutdown, there are no explicit verification steps or feedback loops (e.g., how to validate that shutdown completed cleanly, or how to verify connection pool behavior). | 2 / 3 |
Progressive Disclosure | The entire skill is a monolithic document with 7 detailed patterns, debugging tips, and best practices all inline. At ~350+ lines, this content would benefit significantly from splitting patterns into separate files with the SKILL.md serving as an overview with links. No external references or navigation structure exists. | 1 / 3 |
Total | 8 / 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
27a7ed9
- 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.