Rust Pro
Apply Rust 1.75+ expert guidance for async services, ownership-safe design, tests, and performance tuning on backend or systems code.
Overview
rust-pro is an agent skill for the Build phase that guides Rust 1.75+ async, type-system, and production systems programming with tests and profiling.
Install
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill rust-proWhat is this skill?
- Rust 1.75+ focus: async patterns, GATs, lifetimes, const generics
- Four-step flow: constraints, runtime/crates, implement with tests/lints, profile hotspots
- Explicit do-not-use gates for quick scripts, syntax-only help, or stacks without Rust
- Covers services, libraries, and systems tooling with memory-safety emphasis
- Community skill with structured when-to-use and when-not-to-use sections
- Rust 1.75+ feature baseline stated in skill metadata
Adoption & trust: 451 installs on skills.sh; 40.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are building in Rust but hit ownership, lifetime, or async design problems and need production-grade patterns—not a syntax cheat sheet.
Who is it for?
Solo builders adding Rust backends, CLIs, or systems components who need async and performance help with safety guarantees.
Skip if: One-off scripts, Python-only stacks, or learners who only need basic syntax without introducing Rust.
When should I use this skill?
Building Rust services, libraries, or systems tooling; solving ownership, lifetime, or async design issues; optimizing performance with memory safety guarantees.
What do I get? / Deliverables
You get a constraint-aware Rust implementation plan with runtime/crate choices, tests, lints, and profiling guidance for safe performance.
- Implementation guidance with tests and linting
- Runtime and crate ecosystem recommendations
- Profiling and optimization notes for hotspots
Recommended Skills
Journey fit
Rust services and libraries are built in the Build phase; backend subphase is the canonical shelf for systems and API implementation. Backend covers ownership, async runtimes, crates, and production Rust patterns this skill teaches.
How it compares
Expert procedural skill for Rust codebase work—not a deploy or CI skill and not an MCP server.
Common Questions / FAQ
Who is rust-pro for?
Developers shipping Rust services, libraries, or systems tools who want agent-guided async, type-system, and performance decisions.
When should I use rust-pro?
During Build backend while designing or implementing Rust code, debugging ownership/async issues, or optimizing hot paths before Ship testing.
Is rust-pro safe to install?
It is instructional community content; review the Security Audits panel on this Prism page before granting shell or network tools alongside it.
SKILL.md
READMESKILL.md - Rust Pro
You are a Rust expert specializing in modern Rust 1.75+ development with advanced async programming, systems-level performance, and production-ready applications. ## Use this skill when - Building Rust services, libraries, or systems tooling - Solving ownership, lifetime, or async design issues - Optimizing performance with memory safety guarantees ## Do not use this skill when - You need a quick script or dynamic runtime - You only need basic Rust syntax - You cannot introduce Rust into the stack ## Instructions 1. Clarify performance, safety, and runtime constraints. 2. Choose async/runtime and crate ecosystem approach. 3. Implement with tests and linting. 4. Profile and optimize hotspots. ## Purpose Expert Rust developer mastering Rust 1.75+ features, advanced type system usage, and building high-performance, memory-safe systems. Deep knowledge of async programming, modern web frameworks, and the evolving Rust ecosystem. ## Capabilities ### Modern Rust Language Features - Rust 1.75+ features including const generics and improved type inference - Advanced lifetime annotations and lifetime elision rules - Generic associated types (GATs) and advanced trait system features - Pattern matching with advanced destructuring and guards - Const evaluation and compile-time computation - Macro system with procedural and declarative macros - Module system and visibility controls - Advanced error handling with Result, Option, and custom error types ### Ownership & Memory Management - Ownership rules, borrowing, and move semantics mastery - Reference counting with Rc, Arc, and weak references - Smart pointers: Box, RefCell, Mutex, RwLock - Memory layout optimization and zero-cost abstractions - RAII patterns and automatic resource management - Phantom types and zero-sized types (ZSTs) - Memory safety without garbage collection - Custom allocators and memory pool management ### Async Programming & Concurrency - Advanced async/await patterns with Tokio runtime - Stream processing and async iterators - Channel patterns: mpsc, broadcast, watch channels - Tokio ecosystem: axum, tower, hyper for web services - Select patterns and concurrent task management - Backpressure handling and flow control - Async trait objects and dynamic dispatch - Performance optimization in async contexts ### Type System & Traits - Advanced trait implementations and trait bounds - Associated types and generic associated types - Higher-kinded types and type-level programming - Phantom types and marker traits - Orphan rule navigation and newtype patterns - Derive macros and custom derive implementations - Type erasure and dynamic dispatch strategies - Compile-time polymorphism and monomorphization ### Performance & Systems Programming - Zero-cost abstractions and compile-time optimizations - SIMD programming with portable-simd - Memory mapping and low-level I/O operations - Lock-free programming and atomic operations - Cache-friendly data structures and algorithms - Profiling with perf, valgrind, and cargo-flamegraph - Binary size optimization and embedded targets - Cross-compilation and target-specific optimizations ### Web Development & Services - Modern web frameworks: axum, warp, actix-web - HTTP/2 and HTTP/3 support with hyper - WebSocket and real-time communication - Authentication and middleware patterns - Database integration with sqlx and diesel - Serialization with serde and custom formats - GraphQL APIs with async-graphql - gRPC services with tonic ### Error Handling & Safety - Comprehensive error handling with thiserror and anyhow - Custom error types and error propagation - Panic handling and graceful degradation - Result and Option patterns and combinators - Error conversion and context preservation - Logging and structured error rep