m07-concurrency
CRITICAL: Use for concurrency/async. Triggers: E0277 Send Sync, cannot be sent between threads, thread, spawn, channel, mpsc, Mutex, RwLock, Atomic, async, await, Future, tokio, deadlock, race condition, 并发, 线程, 异步, 死锁
54
61%
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 ./skills/m07-concurrency/SKILL.mdQuality
Discovery
72%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 excels at trigger term coverage with an impressive list of specific keywords spanning error codes, types, frameworks, and even multilingual terms. However, it critically lacks specificity about what the skill actually does — it reads more like a keyword index than a capability description. Adding concrete actions (e.g., 'Diagnoses and fixes thread safety errors, implements async patterns, resolves deadlocks') would significantly improve it.
Suggestions
Add concrete action verbs describing what the skill does, e.g., 'Diagnoses thread safety errors, implements async/await patterns, resolves deadlocks, and guides correct usage of Mutex/RwLock/channels in Rust.'
Restructure to separate the 'what it does' from the 'when to use it' — e.g., start with capability description, then follow with 'Use when...' and the trigger terms.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (concurrency/async) and lists many specific technical concepts (Mutex, RwLock, tokio, channels, etc.), but it doesn't describe concrete actions — it only says 'Use for concurrency/async' without specifying what it actually does (e.g., 'diagnoses thread safety errors', 'implements async patterns'). | 2 / 3 |
Completeness | The 'when' is well-covered with explicit trigger terms and a 'Use for' clause. However, the 'what' is extremely weak — it only says 'concurrency/async' without describing what actions or guidance the skill provides. The description answers when but barely answers what. | 2 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms including Rust error codes (E0277), specific types (Mutex, RwLock, Atomic, mpsc), frameworks (tokio), concepts (deadlock, race condition, async, await, Future), and even multilingual terms (并发, 线程, 异步, 死锁). These are terms users would naturally use when encountering concurrency issues. | 3 / 3 |
Distinctiveness Conflict Risk | The description carves out a very clear niche around Rust concurrency and async programming with highly specific trigger terms like E0277, Send/Sync traits, tokio, and Rust-specific types. This is unlikely to conflict with other skills. | 3 / 3 |
Total | 10 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid reference-style concurrency skill that provides good decision frameworks and error-to-design-question mappings. Its main weaknesses are redundancy across sections (the same CPU/IO/sharing decisions appear in three different formats), limited executable code examples, and lack of validation/verification steps after applying fixes. The 'Trace Up' pattern with domain detection is a unique strength.
Suggestions
Consolidate the overlapping decision content (Thinking Prompt, Trace Down, Decision Flowchart, Quick Reference) into a single authoritative decision table or flowchart to reduce redundancy.
Replace the comments-only Non-Send example with complete, executable Rust code showing each option (Arc replacement, spawn_local usage, drop-before-await).
Add a verification step after each common error fix, e.g., 'After switching Rc to Arc, run `cargo check` to confirm Send bounds are satisfied.'
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is reasonably efficient but has some redundancy — the decision flowchart, quick reference table, and trace-down section all cover overlapping ground. The 'Thinking Prompt' and 'Trace Down' sections repeat the same CPU-bound vs I/O-bound decision. Some tables (like Send/Sync markers) explain concepts Claude already knows well. | 2 / 3 |
Actionability | The skill provides decision frameworks and reference tables rather than executable code. The two Rust code snippets (MutexGuard across await, Non-Send types) are helpful but the Non-Send example is comments-only pseudocode. Most guidance is at the 'use X pattern' level rather than copy-paste ready implementations. | 2 / 3 |
Workflow Clarity | The 'Trace Up' and 'Trace Down' sections provide a diagnostic workflow, and the decision flowchart gives clear sequencing. However, there are no explicit validation checkpoints — no steps to verify the fix works, no feedback loops for error recovery after applying a concurrency pattern change. | 2 / 3 |
Progressive Disclosure | The skill references related skills (m02-resource, m03-mutability, domain-web, etc.) which is good progressive disclosure. However, the main file itself is quite long (~180 lines) with multiple overlapping sections that could be consolidated. No bundle files exist to offload detailed content, and the inline content could benefit from better separation. | 2 / 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 |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
- Repository
- actionbook/rust-skills
- Commit
fa60f79
- 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.