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, 并发, 线程, 异步, 死锁

Quality

61%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/m07-concurrency/SKILL.md

Quality

Content

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

Description

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

Validation

90%

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 — 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: 29 days 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.