rust-engineer

Implement safe Rust code with ownership, lifetimes, and clippy testing.

Updated Jan 9, 2026
One-click install
npx skills add https://github.com/dieu-donnee/luxtrax --skill rust-engineer-dieu-donnee
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-engineer
Source: https://github.com/dieu-donnee/luxtrax/tree/main/.agent/skills/rust-engineer
Command: npx skills add https://github.com/dieu-donnee/luxtrax --skill rust-engineer-dieu-donnee

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Rust code can be error-prone when handling ownership, lifetimes, and unsafe blocks; this skill provides idiomatic patterns and guidance to write memory-safe, high-performance systems in Rust.

Core Features & Use Cases

  • Ownership & Borrowing: design APIs that enforce safe ownership, avoid data races, and minimize unnecessary cloning.
  • Traits & Generics: build modular, reusable interfaces with trait hierarchies and generic bounds.
  • Async & Systems Programming: implement concurrent applications with tokio and zero-cost abstractions for performance.
  • Use Case: develop a small library offering a safe concurrency primitive with a clean API for downstream users.

Quick Start

Write a minimal Rust snippet that demonstrates safe ownership and a trait-based API.

Frequently Asked Questions about rust-engineer

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

FAQPage Schema
How do I design Rust APIs that enforce safe ownership and avoid unnecessary cloning?

To implement safe Rust ownership, enforce strict lifetime rules and borrow checking to prevent data races while minimizing unnecessary cloning. This approach ensures memory safety without runtime overhead.

What is the best way to build modular trait hierarchies with generic bounds in Rust?

Building modular Rust trait hierarchies requires defining reusable interfaces with generic bounds. This creates flexible, trait-based APIs that enable zero-cost abstractions and compile-time polymorphism across libraries.

How do I implement concurrent applications using tokio and zero-cost abstractions in Rust?

Implementing concurrent Rust applications with tokio involves using async programming patterns alongside zero-cost abstractions. This achieves high-performance systems programming without unsafe blocks.

Do I need to avoid unsafe blocks entirely to write memory-safe systems in Rust?

Writing memory-safe Rust systems requires minimal unsafe usage rather than complete avoidance. Strict adherence to ownership rules and testing with clippy and rustfmt ensures reliability across libraries and services.

Can I use this approach to develop a safe concurrency primitive library in Rust?

Yes, you can develop a small Rust library offering safe concurrency primitives with a clean API. This applies ownership rules and trait-based design to provide reliable downstream interfaces.