jbvc/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.
59
59%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
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, writes async trait implementations, handles errors across async boundaries, and builds concurrent task pipelines'.
Expand trigger terms to include common variations users would naturally say: 'futures', 'async/await', 'tokio::spawn', 'runtime configuration', 'Pin', 'Stream', 'select!', 'join!'.
| 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
22%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 hollow shell that delegates all substantive content to an external playbook while providing no actionable Rust async guidance in the main file. The instructions are entirely generic boilerplate that could apply to any skill in any domain. Without concrete code examples, specific Tokio patterns, or meaningful workflow steps, this skill fails to teach Claude anything about async Rust programming.
Suggestions
Add at least 2-3 concrete, executable Rust code examples demonstrating core async patterns (e.g., spawning tasks with tokio::spawn, using channels, basic async error handling with anyhow/thiserror).
Replace the generic instruction bullets with Rust-async-specific guidance, such as when to use tokio::spawn vs join!, how to handle cancellation safety, or common pitfalls like holding locks across await points.
Add a quick-start section with a minimal working async Rust example (e.g., a basic Tokio main function with a spawned task) so the skill provides immediate value without requiring the external resource.
Summarize what's in resources/implementation-playbook.md with specific topic labels (e.g., 'Stream processing patterns', 'Graceful shutdown', 'Connection pooling') so Claude knows when to consult it.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is short but much of it is generic filler ('Clarify goals, constraints, and required inputs', 'Apply relevant best practices') that adds no Rust-async-specific value. It's not verbose in the traditional sense, but the tokens it does spend are largely wasted on boilerplate. | 2 / 3 |
Actionability | There are no concrete code examples, no specific commands, no executable patterns, and no Rust-specific guidance whatsoever. The instructions are entirely abstract ('Apply relevant best practices and validate outcomes') and describe rather than instruct. | 1 / 3 |
Workflow Clarity | There is no meaningful workflow or sequence of steps. The four bullet points under Instructions are generic platitudes with no specific sequencing, validation checkpoints, or error recovery guidance for async Rust development. | 1 / 3 |
Progressive Disclosure | The skill does reference a separate resource file (resources/implementation-playbook.md) which is appropriate one-level-deep disclosure. However, the SKILL.md itself provides essentially zero useful overview content, so the reader gets no value without navigating to the external file. | 2 / 3 |
Total | 6 / 12 Passed |
Validation
100%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.
Reviewed
Table of Contents