rust-development · laurigates — Claude Code skill: what it does, how to install
A Rust development skill covering Cargo, ownership, async code, and Tokio. It fits coding tasks that mention Rust or its core tooling.
MIT 108 installs ★ 60 updated 2026-11-16
npx skills add laurigates/claude-plugins --skill rust-development -a claude-codeWhat rust-development does
This skill gives an agent working knowledge for Rust development. It can guide module and trait design, ownership and borrowing, lifetimes, type-safe error handling, async/await, and memory-aware abstractions. Its ecosystem coverage includes Cargo, Tokio, Serde, Rayon, and common Rust testing tools.
The reference material covers build and test workflows, Clippy checks, rustfmt, dependency audits, profiling, fuzzing, Miri, and cross-compilation. It also lists patterns for Result<T, E>, Option<T>, smart pointers, interior mutability, and Pin/Unpin. The skill is automatic rather than manually invoked, with triggers around Rust, cargo, ownership, lifetimes, and async programming.
For CI, the guidance recommends pinning the compiler in a root rust-toolchain.toml and letting Renovate update it. That choice affects how new compiler lints arrive in the project.
What it helps with
- design Rust modules and trait hierarchies
- untangle ownership, borrowing, and lifetime errors
- build async services with Tokio
- run Clippy and rustfmt checks
- set up tests, benchmarks, and dependency audits
Example prompts for the agent
- Review this Rust code and fix the ownership and lifetime issues.
- Set up a project workflow with
cargo clippy,cargo fmt, andcargo test. - Suggest a module layout for a Rust library that uses Tokio and Serde.
How to install rust-development
1Skills CLI (Vercel)
npx skills add laurigates/claude-plugins --skill rust-development -a claude-code2Manually: put the files in place
~/.claude/skills/rust-development/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/rust-development/
1Skills CLI (Vercel)
npx skills add laurigates/claude-plugins --skill rust-development -a codex2Manually: put the files in place
.agents/skills/rust-development/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add laurigates/claude-plugins --skill rust-development -a cursor2Manually: put the files in place
.cursor/skills/rust-development/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install laurigates/claude-plugins rust-plugin/skills/rust-development2Manually: put the files in place
.github/skills/rust-development/SKILL.md1Skills CLI (Vercel)
npx skills add laurigates/claude-plugins --skill rust-development -a gemini-cli2Platform CLI
gemini skills install https://github.com/laurigates/claude-plugins --path rust-plugin/skills/rust-developmentManually: put the files in place
.devin/skills/rust-development/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add laurigates/claude-plugins --skill rust-development -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about rust-development
How do I install rust-development in Claude Code?
Run npx skills add laurigates/claude-plugins --skill rust-development -a claude-code, then check ~/.claude/skills/rust-development/SKILL.md.
What does rust-development do?
It helps an agent work on Rust code, including ownership, memory safety, async programming, error handling, testing, and Cargo workflows.
Which Rust tools does the skill cover?
It covers Cargo, Rustc, Clippy, Rustfmt, and rust-analyzer, with additional guidance for Tokio, Serde, Rayon, Miri, and cargo-fuzz.
Source text
SKILL.md · MIT
---
created: 2025-12-16
modified: 2026-11-14
reviewed: 2026-04-25
name: rust-development
description: Rust development — cargo, clippy, rustfmt, async, Tokio, Serde, memory safety. Use when mentioning Rust, cargo, ownership, lifetimes, fearless concurrency, or async programming.
user-invocable: false
allowed-tools: Glob, Grep, Read, Bash(cargo build *), Bash(cargo run *), Bash(cargo test *), Bash(cargo bench *), Bash(cargo clippy *), Bash(cargo fmt *), Bash(cargo fix *), Bash(cargo add *), Bash(cargo update *), Bash(cargo audit *), Bash(cargo deny *), Bash(cargo new *), Bash(cargo init *), Bash(cargo doc *), Edit, Write, TodoWrite, WebFetch, WebSearch
---
# Rust Development
Expert knowledge for modern systems programming with Rust, focusing on memory safety, fearless concurrency, and zero-cost abstractions.
## When to Use This Skill
| Use this skill when... | Use sibling skill instead when... |
|---|---|
| Writing Rust code, ownership, lifetimes, async/await | Configuring lint rules in detail -- use `clippy-advanced` |
| Choosing crates from the ecosystem (Tokio, Serde) | Detecting unused dependencies -- use `cargo-machete` |
| Designing module structure or trait hierarchies | Running tests with parallel isolation -- use `cargo-nextest` |
| Learning idiomatic Rust patterns and edition features | Generating coverage reports -- use `cargo-llvm-cov` |
## Core Expertise
**Modern Rust Ecosystem**
- **Cargo**: Build system, package manager, and workspace management
- **Rustc**: Compiler optimization, target management, and cross-compilation
- **Clippy**: Linting for idiomatic code and performance improvements
- **Rustfmt**: Consistent code formatting following Rust style guidelines
- **Rust-analyzer**: Advanced IDE support with LSP integration
**Language Features**
- Rust 2024 edition: RPITIT, async fn in traits, impl Trait improvements
- Const generics and compile-time computation
- Generic associated types (GATs)
- Let-else patterns and if-let chains
## Key Capabilities
**Ownership & Memory Safety**
- Implement ownership patterns with borrowing and lifetimes
- Design zero-copy abstractions and efficient memory layouts
- Apply RAII patterns through Drop trait and smart pointers (Box, Rc, Arc)
- Leverage interior mutability patterns (Cell, RefCell, Mutex, RwLock)
- Use Pin/Unpin for self-referential structures
**Async Programming & Concurrency**
- **Tokio**: Async runtime for high-performance network applications
- **async-std**: Alternative async runtime with familiar API design
- **Futures**: Composable async abstractions and stream processing
- **Rayon**: Data parallelism with work-stealing thread pools
- Design lock-free data structures with atomics and memory ordering
**Error Handling & Type Safety**
- Design comprehensive error types with thiserror and anyhow
- Implement Result<T, E> and Option<T> patterns effectively
- Use pattern matching for exhaustive error handling
- Apply type-state patterns for compile-time guarantees
**Performance Optimization**
- Profile with cargo-flamegraph, perf, and criterion benchmarks
- Optimize with SIMD intrinsics and auto-vectorization
- Implement zero-cost abstractions and inline optimizations
- Use unsafe code judiciously with proper safety documentation
**Testing & Quality Assurance**
- **Unit Testing**: #[test] modules with assertions
- **Integration Testing**: tests/ directory for end-to-end validation
- **Criterion**: Micro-benchmarking with statistical analysis
- **Miri**: Undefined behavior detection in unsafe code
- **Fuzzing**: cargo-fuzz for security and robustness testing
## Essential Commands
```bash
# Project setup
cargo new my-project # Binary crate
cargo new my-lib --lib # Library crate
cargo init # Initialize in existing directory
# From a template repo instead of an empty crate — see the cargo-generate skill
cargo generate --git <template-url> --name my-project
# Development workflow
cargo build # Debug build
cargo build --release # Optimized build
cargo run # Build and run
cargo run --release # Run optimized
cargo test # Run all tests
cargo test --lib # Library tests only
cargo bench # Run benchmarks
# Code quality
cargo clippy # Lint code
cargo clippy -- -W clippy::pedantic # Stricter lints
cargo fmt # Format code
cargo fmt --check # Check formatting
cargo fix # Auto-fix warnings
# Dependencies
cargo add serde --features derive # Add dependency
cargo update # Update deps
cargo audit # Security audit
cargo deny check # License/advisory check
# Advanced tools
cargo expand # Macro expansion
cargo flamegraph # Profile with flame graph
cargo doc --open # Generate and open docs
cargo miri test # Check for UB
# Cross-compilation
rustup target add wasm32-unknown-unknown
cargo build --target wasm32-unknown-unknown
```
## Best Practices
**Idiomatic Rust Patterns**
```rust
// Use iterators over manual loops
let sum: i32 = numbers.iter().filter(|x| **x > 0).sum();
// Prefer combinators for Option/Result
let value = config.get("key")
.and_then(|v| v.parse().ok())
.unwrap_or_default();
// Use pattern matching effectively
match result {
Ok(value) if value > 0 => process(value),
Ok(_) => handle_zero(),
Err(e) => return Err(e.into()),
}
// Let-else for early returns
let Some(config) = load_config() else {
return Err(ConfigError::NotFound);
};
```
**Project Structure**
```
my-project/
├── Cargo.toml
├── src/
│ ├── lib.rs # Library root
│ ├── main.rs # Binary entry point
│ ├── error.rs # Error types
│ └── modules/
│ └── mod.rs
├── tests/ # Integration tests
├── benches/ # Benchmarks
└── examples/ # Example programs
```
**Error Handling**
```rust
use thiserror::Error;
#[derive(Error, Debug)]
pub enum AppError {
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
#[error("parse error: {message}")]
Parse { message: String },
#[error("not found: {0}")]
NotFound(String),
}
pub type Result<T> = std::result::Result<T, AppError>;
```
**Common Crates**
| Crate | Purpose |
|-------|---------|
| `serde` | Serialization/deserialization |
| `tokio` | Async runtime |
| `reqwest` | HTTP client |
| `sqlx` | Async SQL |
| `clap` | CLI argument parsing |
| `tracing` | Logging/diagnostics |
| `anyhow` | Application errors |
| `thiserror` | Library errors |
**CI toolchain**: pin the compiler in a root `rust-toolchain.toml` that Renovate bumps, so a new release's lints arrive as a PR; see [clippy-advanced § Pin the toolchain](../clippy-advanced/REFERENCE.md#pin-the-toolchain).
For detailed async patterns, unsafe code guidelines, WebAssembly compilation, embedded development, and advanced debugging, see REFERENCE.md.
© laurigates · MIT · laurigates/claude-plugins
Similar skills
All skills for Programming languages →rust-development by other authors comes first.