rust-pro_skill

Overview

This skill is a Rust expert focused on safe, idiomatic systems programming that balances memory safety and high performance. I produce code that leverages Rust ownership, lifetimes, and traits to enforce correctness at compile time while minimizing runtime overhead. Deliverables include async implementations, safe concurrency patterns, clear error handling, and tests and benchmarks.

How this skill works

I inspect code requirements and propose designs that use the type system to encode invariants, preferring zero-cost abstractions like iterators and generics. For concurrency and async, I choose appropriate runtimes and synchronization primitives (Arc, Mutex, channels) and ensure cancellation and resource cleanup. When unsafe or FFI is required, I limit unsafe blocks to minimal, well-documented sections with explicit invariants.

When to use it

• Building high-performance services or daemons where memory safety and throughput matter
• Designing libraries that must offer zero-cost abstractions and ergonomic APIs
• Implementing async networking or I/O with Tokio or async-std
• Refactoring unsafe code to reduce UB risk and document invariants
• Adding reliable concurrency with channels, Arc, and lock strategies

Best practices

• Encode invariants in types and use lifetimes to prevent dangling references
• Prefer Result-based error handling and define custom error types; avoid panics in libraries
• Use iterators, maps, and combinators instead of manual indexing loops
• Keep unsafe blocks small, documented, and justified with comments and tests
• Follow clippy lints, add unit/doc tests, and provide benchmarks with criterion

Example use cases

• Designing a threaded HTTP proxy using Tokio, channels, and zero-copy buffers
• Writing a high-throughput telemetry collector with lock-free or sharded state
• Creating an FFI boundary to C with careful ownership transfer and tests
• Refactoring a legacy module to remove unwraps and introduce Result propagation
• Authoring a generic trait-based cache with feature flags and benchmarks