m07-concurrency

Identify and resolve Rust concurrency and async errors without modifying code.

1|Updated Apr 4, 2026
One-click install
npx skills add https://github.com/Jylhis/claude-marketplace --skill m07-concurrency-jylhis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: m07-concurrency
Source: https://github.com/Jylhis/claude-marketplace/tree/main/plugins/rust-dev/skills/m07-concurrency
Command: npx skills add https://github.com/Jylhis/claude-marketplace --skill m07-concurrency-jylhis

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Rust developers often face compile errors related to Send/Sync traits, deadlocks, and choosing between threading and async runtimes, leading to unsafe or inefficient concurrency implementations.

Core Features & Use Cases

  • Error‑to‑Design Mapping: Translates common concurrency errors (e.g., E0277) into design questions.
  • Domain‑Aware Guidance: Detects project context (web, CLI, fintech, etc.) and suggests appropriate thread‑safety strategies.
  • Decision Flowcharts: Provides step‑by‑step pathways for selecting threads, async/await, synchronization primitives, or message passing.
  • Traceability: Encourages tracing up to domain constraints and down to concrete implementations.
  • Pattern Library: Lists safe patterns for std::thread, rayon, tokio, Arc, Mutex, RwLock, channels, and atomics.

Quick Start

Ask the concurrency skill to analyze your Rust code and recommend the proper async or threading approach.

Frequently Asked Questions about m07-concurrency

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I fix Rust Send and Sync trait compile errors in async code?

To resolve Rust Send and Sync trait compile errors, map the specific error like E0277 to design questions about your async boundaries. This Skill analyzes your concurrency failures and recommends appropriate thread-safety strategies, selecting proper synchronization primitives or restructuring async tasks.

What is the best way to choose between tokio async and std::thread for my Rust project?

Choosing between tokio async and std::thread requires evaluating your domain constraints and workload type. This Skill provides decision flowcharts that trace project context to recommend the correct concurrency model, synchronization primitives, and message passing patterns for safe implementation.

Why does my Rust async code deadlock with Mutex?

Your Rust async code deadlocks with Mutex because holding a lock across an await point blocks the executor thread. This Skill identifies deadlocks and suggests safe concurrency patterns using alternatives like channels, RwLock, or atomics to prevent blocking async runtime tasks.

How do I select the right synchronization primitive for Rust thread safety?

To select the right Rust synchronization primitive, evaluate whether your workload needs exclusive write access or concurrent reads. This Skill lists safe patterns for Arc, Mutex, RwLock, channels, and atomics, matching them to your specific domain constraints and threading model.

Can I use rayon and tokio together in the same Rust application?

You can use rayon and tokio together by offloading CPU-bound parallel tasks to rayon while tokio handles async I/O. This Skill provides guidance on selecting threads, async runtimes, and message passing to ensure safe integration without modifying your existing code.