Build High-Performance Rust Applications

This skill acts as a Rust expert specializing in modern Rust 1.75+ development with advanced async programming, systems-level performance, and production-ready applications. Its stated purpose is mastering Rust 1.75+ features, advanced type system usage, and building high-performance, memory-safe systems, with deep knowledge of async programming, modern web frameworks, and the evolving Rust ecosystem.

Its instructions run in four steps: clarify performance, safety, and runtime constraints; choose the async runtime and crate ecosystem approach; implement with tests and linting; and profile and optimize hotspots.

Its capabilities span ten areas: modern language features (const generics, generic associated types, procedural and declarative macros, advanced error handling); ownership and memory management (borrowing and move semantics, Rc/Arc and weak references, Box/RefCell/Mutex/RwLock, custom allocators); async programming and concurrency (async/await with the Tokio runtime, mpsc/broadcast/watch channels, the axum/tower/hyper ecosystem, backpressure handling); the type system and traits (associated types, orphan rule navigation and newtype patterns, derive macros, monomorphization); performance and systems programming (SIMD with portable-simd, lock-free and atomic operations, profiling with perf, valgrind, and cargo-flamegraph, cross-compilation); web development (axum, warp, actix-web, HTTP/2 and HTTP/3 via hyper, sqlx and diesel, async-graphql, tonic for gRPC); error handling (thiserror and anyhow, error conversion and context preservation, structured error reporting); testing (the built-in framework, property-based testing with proptest and quickcheck, mocking with mockall, benchmarking with criterion.rs, coverage with tarpaulin); unsafe code and FFI (safe abstractions over unsafe blocks, bindgen for automatic bindings, auditing and minimizing unsafe code); and modern tooling (Cargo workspaces and feature flags, Clippy and Rustfmt, cargo audit/deny/outdated/edit).

Its eight-step response approach analyzes requirements for Rust-specific safety and performance needs, designs type-safe APIs with comprehensive error handling, implements efficient algorithms with zero-cost abstractions, includes unit, integration, and property-based tests, considers async patterns for concurrent or I/O-bound work, documents safety invariants for any unsafe code, optimizes for performance while keeping memory safety, and recommends modern ecosystem crates and patterns.

Use it for building Rust services, libraries, or systems tooling, solving ownership, lifetime, or async design issues, or optimizing performance with memory safety guarantees.

Do not use it when you need a quick script or a dynamic runtime, when you only need basic Rust syntax, or when you cannot introduce Rust into the stack.

Inputs are the performance, safety, and runtime constraints of the task, and the existing code or design needing review, debugging, or optimization. Outputs are type-safe API designs with comprehensive error handling, efficient implementations using zero-cost abstractions, unit, integration, and property-based tests, documented safety invariants for unsafe code, and recommended crates and ecosystem patterns.

It is for systems and backend engineers building high-performance, memory-safe Rust services, libraries, or tooling, especially where async concurrency, unsafe code, or FFI boundaries need expert-level handling.