rust-expert

Solid

Expert Rust idiomatique pour développement CLI/système. Ownership, error handling avec anyhow/thiserror, traits, async Tokio, testing. Utiliser pour coder, reviewer ou refactorer du Rust.

Code & Development 91 stars 6 forks Updated 1 weeks ago MIT

Install

View on GitHub

Quality Score: 86/100

Stars 20%
65
Recency 20%
90
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

# Rust Expert Skill Expert in idiomatic Rust 1.75+ development with focus on CLI/system tools, ownership patterns, error handling, traits, async programming, and testing. ## Core Competencies ### 1. Ownership & Borrowing Mastery - Prefer `&str` over `String` for function parameters - Use slices (`&[T]`) over `Vec<T>` when ownership not needed - Leverage `Cow<str>` for conditionally owned strings - Apply `Arc<T>` and `Arc<Mutex<T>>` for thread-safe sharing - Design lifetimes explicitly when necessary ### 2. Error Handling Excellence - **Default**: `anyhow::Result<T>` for applications - **Libraries**: `thiserror` for custom error types - **Context**: Always use `.context("operation description")` with `?` - **No unwrap**: Use `?` operator or `expect()` with justification - **Recovery**: Provide actionable error messages ### 3. Trait-Driven Design - Implement standard traits: `Debug`, `Clone`, `Default`, `Display` - Use trait objects (`dyn Trait`) for runtime polymorphism - Leverage trait bounds for generic constraints - Organize impl blocks immediately after type definitions - Apply async traits (native in Rust 1.75+) ### 4. Async Programming Patterns - **Runtime**: Tokio for production async - **Patterns**: `async fn`, `tokio::spawn`, `tokio::select` macro (with `!`) - **Streams**: `tokio_stream` for async iteration - **Rate limiting**: `governor` crate for API throttling - **Retries**: Exponential backoff with `tokio::time::sleep` ### 5. CLI Development Best Practices ...

Details

Author
FlorianBruniaux
Repository
FlorianBruniaux/ccboard
Created
6 months ago
Last Updated
1 weeks ago
Language
Rust
License
MIT

Integrates with

Bundled in these plugins

Similar Skills

Semantically similar based on skill content — not just same category

Code & Development Listed

rust-expert

This skill should be used when the user is writing, reviewing, debugging, or architecting Rust code. Detects edition and toolchain from the project. Provides expert critique covering ownership, error handling, unsafe review, async correctness, trait design, type system patterns, performance, SOLID principles, and Cargo/workspace practices. Use when the user asks "critique my Rust code", "review this module", "fix borrow checker error", "is this unsafe sound", "design error types", "optimize this function", "review async code", "structure my workspace", "why is the borrow checker complaining", "help with lifetimes", "make this more idiomatic", or "review my Cargo.toml".

3 Updated yesterday
mathisk2095
API & Backend Solid

rc-rust

Rust as a language — ownership and lifetimes, error hierarchies with thiserror/anyhow, async with Tokio, trait design, testing, performance, clippy, and rustdoc. Use when writing or reviewing Rust code, deciding between borrowing and cloning, designing an error type, structuring async tasks and channels, or configuring lints and benchmarks. Do not use for Axum HTTP routing and middleware (rc-axum), SQLx/Postgres data access (rc-sqlx), SvelteKit (rc-sveltekit), or non-Rust languages.

19 Updated 2 weeks ago
rodolfochicone
AI & Automation Featured

rust-engineer

Writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions. Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling with Result/Option. Use when building Rust applications, solving ownership or borrowing issues, designing trait-based APIs, implementing async/await concurrency, creating FFI bindings, or optimizing for performance and memory safety. Invoke for Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming.

11,089 Updated 1 weeks ago
Jeffallan