Rust development toolkit with best practices, code review, performance optimization, and async Rust patterns

GitHub stars
299

Install

/plugin install rust-dev@spellbook

Run it inside Claude Code after adding the marketplace with /plugin marketplace add majiayu000/spellbook.

Contents

Discovered from source

Agents 2

Security Policy

Supported Versions

VersionSupported
latestYes

Reporting a Vulnerability

  1. Do not open a public issue
  2. Use GitHub Security Advisories
  3. Include steps to reproduce and potential impact

Rust Best Practices Assistant

Core Principles

  • Prefer safe Rust; use unsafe only when absolutely necessary and well-documented
  • Leverage the type system to prevent bugs at compile time
  • Use Result<T, E> for error handling, avoid panic! in library code
  • Make illegal states unrepresentable through proper type design

Code Style

  • Format all code with rustfmt
  • Follow all clippy suggestions (run with cargo clippy -- -W clippy::pedantic)
  • Use snake_case for variables and functions
  • Use CamelCase for types and traits
  • Use SCREAMING_SNAKE_CASE for constants

Memory & Ownership

  • Prefer borrowing (&T, &mut T) over ownership when possible
  • Use Cow<str> for strings that might be borrowed or owned
  • Avoid unnecessary .clone() - consider borrowing or restructuring
  • Use Arc<T> for shared ownership across threads, Rc<T> for single-threaded

Error Handling

  • Use thiserror for defining library error types
  • Use anyhow for application-level error handling
  • Provide meaningful, actionable error messages
  • Use ? operator for error propagation

Performance

  • Avoid unnecessary heap allocations
  • Prefer iterators over manual loops (zero-cost abstraction)
  • Use &str instead of String for function parameters when possible
  • Consider using SmallVec for small, stack-allocated vectors

Async Rust

  • Use tokio as the async runtime for most applications
  • Prefer async fn over manual Future implementations
  • Avoid blocking operations in async contexts
  • Use tokio::spawn for concurrent tasks

Testing

  • Write unit tests in the same file using #[cfg(test)] module
  • Use #[should_panic] for testing panic behavior
  • Use proptest or quickcheck for property-based testing
  • Aim for meaningful test coverage, not just line coverage

Common Patterns

  • Use the builder pattern for complex object construction
  • Use From and Into traits for type conversions
  • Implement Default when a sensible default exists
  • Use Option<T> instead of sentinel values

What to Avoid

  • Avoid unwrap() in production code; use expect() with context or proper error handling
  • Avoid String when &str suffices
  • Avoid manual memory management when safe abstractions exist
  • Avoid unsafe without thorough documentation and testing

Sponsors

Details

Marketplace
majiayu000/spellbook
Source
plugins/rust-dev
Author
majiayu000
Category
Development

More from majiayu000/spellbook

All 2