rust-engineer

Analyze and implement Rust projects with ownership, async, and performance optimizations.

68|6|Updated Apr 16, 2020
One-click install
npx skills add https://github.com/zenobi-us/dotfiles --skill rust-engineer-zenobi-us
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-engineer
Source: https://github.com/zenobi-us/dotfiles/tree/main/ai/files/skills/experts/language-specialists/rust-engineer
Command: npx skills add https://github.com/zenobi-us/dotfiles --skill rust-engineer-zenobi-us

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides deep Rust expertise for memory-safe, high-performance systems, focusing on ownership, concurrency, and zero-cost abstractions.

Core Features & Use Cases

  • Ownership, borrowing, and safe memory management
  • Async programming, futures, and concurrency patterns
  • Performance optimization, profiling, and low-level design
  • Testing, benchmarks, and code quality tooling

Quick Start

Quick Start: Implement a memory-safe, high-performance module using async/await and zero-unsafe boundaries.

Frequently Asked Questions about rust-engineer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write Rust code that's memory-safe without using unsafe blocks?

Rust's ownership system enforces memory safety at compile time through borrowing rules and lifetimes, eliminating entire classes of bugs without runtime overhead. The rust-engineer Skill guides you through ownership discipline and zero-cost abstractions to build safe systems while maintaining performance.

What's the best way to structure async code and handle concurrency in Rust?

Async/await syntax combined with futures and trait objects enables safe concurrent programming by leveraging Rust's type system. This Skill teaches async patterns, concurrency design, and how to avoid data races through ownership guarantees.

How do I optimize Rust performance and profile bottlenecks?

Performance optimization in Rust involves profiling, zero-cost abstractions, and low-level design choices. This Skill covers benchmarking, code quality tooling, and optimization strategies for embedded and mission-critical systems.

Can I ensure my Rust code meets production quality standards?

Production Rust requires comprehensive testing, documentation with examples, doctests, clippy pedantic compliance, and MIRI verification. This Skill ensures your projects satisfy zero unsafe code boundaries, complete test suites, and reproducible builds with Cargo.lock.

What testing and verification practices should I use for Rust systems?

Comprehensive Rust testing includes unit tests, doctests, benchmarks, and MIRI verification for undefined behavior detection. This Skill covers test suite design and code quality validation for safe, high-performance systems.