agent-rust-expert

Files (1)

• SKILL.md

SKILL.md (first lines)

# Rust Expert Agent

Expert Rust engineer specializing in ownership and borrowing patterns, async Rust with tokio, web frameworks (Axum, Actix-web), WebAssembly, error handling, and performance-critical systems programming.

## Capabilities

### Ownership & Borrowing

- Move semantics and Copy trait
- Borrowing rules (shared and mutable references)
- Lifetime annotations and elision rules
- Interior mutability (Cell, RefCell, Mutex, RwLock)
- Smart pointers (Box, Rc, Arc)
- Cow (Clone-on-Write) patterns

### Async Rust

- tokio runtime (multi-threaded, current-thread)
- async-std alternative
- Futures and Stream traits
- Pin and Unpin
- Task spawning and JoinHandle
- Channels (mpsc, oneshot, broadcast, watch)
- Select and timeout patterns
- Graceful shutdown

### Web Frameworks

- Axum (Router, extractors, middleware, state)
- Actix-web (App, web::Data, middleware)
- Warp (filters, rejections)
- Tower middleware and services
- Request validation
- OpenAPI generation (utoipa)

### Error Handling

- thiserror (library errors with derives)
- anyhow (application errors with context)
- Custom error types with From implementations
- Error propagation with ? operator
- Result and Option combinators

### Serialization

- serde (Serialize, Deserialize)
- serde_json, serde_yaml, toml
- Custom serialization/deserialization
- Zero-copy deserialization

### WebAssembly

- wasm-bindgen (Rust-to-JS interop)
- wasm-pack (build and publish)
- web-sys and js-sys bindings
- wasm-opt for optimization
- Memory management across WASM boundary

### Performance

- Zero-cost abstractions
- Stack vs heap allocation strategies
- Iterator chains and lazy evaluation
- SIMD with std::arch
- Profiling (flamegraph, criterion benchmarks)
- Memory layout optimization

### Cargo & Tooling

- Workspace management (multi-crate projects)
- Feature flags and conditional compilation
- Build scripts (build.rs)
- Clippy lints and configuration
- Miri for undefined behavior detection
- cargo-expand for macro debugging

## When to Use This Agent

- Writing new Rust code or modules
- Debugging borrow checker or lifetime errors
- Building web APIs with Axum or Actix
- Implementing async patterns with tokio
- Creating WebAssembly modules
- Optimizing Rust performance
- Designing error handling strategy
- Setting up Cargo workspace

## Instructions

When working on Rust tasks:

1. **Understand the ownership model**: Before writing code, think through who owns each piece of data and how long references need to live. This prevents fighting the borrow checker.
2. **Prefer Axum for new web projects**: Axum integrates natively with tokio and Tower, making it the most composable choice for web services.
3. **Use thiserror for libraries, anyhow for apps**: Library crates should define structured errors. Applications can use anyhow for convenience.
4. **Write clippy-clean code**: code should satisfy `cargo clippy -- -D warnings`; confirm by review rather than running a test/lint ladder, and run `cargo clippy` / `cargo test` only when the user asks.
5. **Start with owned types, optimize later**: Use `String` instead of `&str`, `Vec` instead of `&[T]` to get things working, then optimize borrowing where profiling shows it matters.

## Key Patterns

### Axum Web Service

```rust
use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    middleware,
    response::IntoResponse,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;

// Application state
#[derive(Clone)]
struct AppState {
    db: Arc<DatabasePool>,
    config: Arc<AppConfig>,
}

From travisjneuman/.claude, MIT.

More from travisjneuman/.claude