PlugWiki

rust-async-patterns (wshobson/agents): a skill for async Rust with Tokio

This wshobson/agents skill gives Claude Tokio patterns for tasks, channels, error handling, shutdown, async traits and streams when it writes async Rust.

Installs
21.5K
on skills.sh
Stars
42.1K
on GitHub
Files
1
besides SKILL.md
Updated
Oct 2026
last repo commit

The skill gives Claude a Quick Start (Cargo dependencies and a #[tokio::main] example), the async execution model, a table of key concepts, and a do and don't list. It triggers when you build async Rust applications, write concurrent network services, use Tokio for async I/O, handle async errors or debug async code.

Seven worked patterns sit in references/details.md: concurrent task execution, channels, async error handling, graceful shutdown, async traits, streams and resource management. A short debugging section follows them.

The do and don't list names common mistakes: blocking with std::thread::sleep inside async code, holding locks across awaits, spawning without limits and forgetting Send bounds. The skill bundles no scripts.

Good for

  • Rust developers building async network services with Tokio
  • Developers debugging async code, such as blocked runtimes or deadlocks
  • Teams who want async Rust reviewed against a short do and don't list

Install rust-async-patterns

Claude Code

  1. 1

    Copy this prompt.

    Install the rust-async-patterns skill in Claude Code. Run this command:

npx skills add https://github.com/wshobson/agents --skill rust-async-patterns

Then check that it loaded and tell me how to use it.
  2. 2

    Paste it into Claude Code. It shows the change and asks before running it.

Requires Node.js.

From its listing on skills.sh. Source.

What's in the skill

When it loads

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.

Sections in SKILL.md

  1. When to Use This Skill
  2. Core Concepts
  3. 1. Async Execution Model
  4. 2. Key Abstractions
  5. Quick Start
  6. Detailed patterns and worked examples
  7. Best Practices
  8. Do's
  9. Don'ts

Key facts

Author
Seth Hobson (wshobson)
License
MIT
Repository
wshobson/agents
Installs on skills.sh
21,508 as of 2026-11-02
GitHub stars
42,081 as of 2026-11-02
Last repo commit
2026-10-30
Files in the skill folder
2 files including SKILL.md (references/details.md holds the patterns)
skills.sh audits
Gen Agent Trust Hub pass, Socket pass, Snyk pass
Part of
The systems-programming plugin in wshobson/agents, a catalog of 94 plugins

What it includes

  • Cargo dependencies and a Tokio main function

    Lists tokio, futures, async-trait, anyhow, tracing and tracing-subscriber, with a small async example.

    Quick start

  • Run many tasks with JoinSet

    Worked example in references/details.md.

    Read · Pattern 1: Concurrent task execution

  • mpsc, broadcast, oneshot and watch

    How tasks talk to each other without shared state.

    Read · Pattern 2: Channels

  • anyhow, thiserror and context

    Propagating and wrapping errors in async code.

    Read · Pattern 3: Async error handling

  • Stop tasks on a signal

    Uses tokio::signal to shut a service down cleanly.

    Read · Pattern 4: Graceful shutdown

  • Traits with async methods via async_trait

    Shows how to define and implement them.

    Read · Pattern 5: Async traits

  • Async iteration with futures streams

    Create, transform and consume streams.

    Read · Pattern 6: Streams

  • RwLock cache and a semaphore-limited pool

    A shared cache using RwLock, and a connection pool whose size is capped with a Semaphore.

    Read · Pattern 7: Resource management

  • tokio-console and tracing instrumentation

    The details file notes running with RUSTFLAGS="--cfg tokio_unstable" for tokio-console.

    Read · Debugging tips

  • Best practices from SKILL.md

    Use select!, prefer channels, use JoinSet, instrument with tracing, never block, do not hold locks across awaits and bound your spawns.

    Do's and don'ts

From the official docs

Questions

What does the rust-async-patterns skill do?

It gives Claude Tokio-based patterns and rules for async Rust. When you ask for concurrent services or help with async bugs, Claude has a Quick Start, seven worked patterns and a list of common mistakes to follow.

How do I install it in Claude Code, the Claude app or Codex?

Use the install box above. The wshobson/agents README says an individual skill can be installed with gh skill install wshobson/agents <skill> or with the npx skills installer, without the plugin's agents, commands or hooks.

Does it only work with Tokio?

The skill is written around Tokio. SKILL.md names Tokio throughout and does not cover other runtimes.

Is it safe to install?

It is two Markdown files with no scripts, API keys or network calls named. It includes Rust code samples and a Cargo dependency list that only run if you ask Claude to add them to your project.

What are the main mistakes it warns about?

Using std::thread::sleep in async code, holding locks across awaits, spawning without limits, ignoring errors and forgetting Send bounds for spawned futures.

Does it help debug stuck tasks?

It has a short debugging section that mentions tokio-console and instrumenting with tracing. The patterns file shows the setup.

Information

updated Nov 2, 2026

Repository
wshobson/agents
Folder
plugins/systems-programming/skills/rust-async-patterns

wshobson/agentsskills.sh

Sources

Docs, issue trackers and discussions this page is built from.

Show all 3
  1. SKILL.md · github.com
  2. references/details.md · github.com
  3. wshobson/agents README · github.com

Updated Nov 2, 2026.