Guide Rust ownership, lifetimes, and unsafe code with reusable patterns.
npx skills add https://github.com/ginkida/rustyhand --skill rust-expert-ginkida
Please help me install this Agent Skill. Skill: rust-expert Source: https://github.com/ginkida/rustyhand/tree/main/crates/rusty-hand-skills/bundled/rust-expert Command: npx skills add https://github.com/ginkida/rustyhand --skill rust-expert-ginkida
Rust's ownership, lifetimes, and unsafe boundaries create conceptual and correctness risks in large codebases. This guide provides expert strategies to write safe, idiomatic Rust and to reason about complex borrow rules without sacrificing performance.
Write a small Rust snippet demonstrating a safe ownership pattern with a mutable reference and a trait.
High-intent search queries and answers about installing and using this skill.
Rust ownership and borrowing errors with mutable references are resolved by applying safe ownership patterns that prevent data races and undefined behavior. This Skill provides expert strategies and concrete examples to help you reason about complex borrow rules without sacrificing performance in large codebases.
The best way to structure unsafe code boundaries in Rust is through safe layering and trait-based abstractions. This approach isolates unsafe blocks while maintaining correct ownership rules, ensuring performance-critical libraries remain safe and idiomatic at scale.
Rust lifetimes in async runtimes and zero-cost abstractions work by enforcing strict borrowing rules across asynchronous execution contexts. This Skill offers practical patterns for async runtimes and error handling, ensuring correct lifetime annotations and safe concurrent operations.
Yes, this Rust guidance thoroughly covers trait-based abstractions for systems programming. It provides reusable patterns and best practices for implementing traits correctly, ensuring safe and idiomatic code across performance-critical applications and libraries.
Rust code fails borrow checks in large codebases due to complex ownership rules and conflicting mutable references. This Skill solves this conceptual risk by providing expert strategies and reusable patterns to reason about borrow rules and write safe, idiomatic Rust.
jyasuuManage Rust toolchains and automate cargo build, test, and cross-compile workflows.
saeed-vayghanAnalyzes Rust code and recommends optimizations for improved performance and maintainability.
dojoengineIdentify and resolve Rust mutability design issues involving borrow conflicts.
khroreImplement memory-safe programming with RAII, ownership, and smart pointers across Rust, C++, and C.
