rust-engineer

Design and implement memory-safe Rust 2021 applications with tokio async and trait-based APIs.

Updated Feb 22, 2026
One-click install
npx skills add https://github.com/kkingsbe/tempest --skill rust-engineer-kkingsbe
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-engineer
Source: https://github.com/kkingsbe/tempest/tree/main/skills/rust-engineer
Command: npx skills add https://github.com/kkingsbe/tempest --skill rust-engineer-kkingsbe

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Senior Rust engineering guidance to design memory-safe, high-performance software and systems. It helps teams implement robust ownership models, safe concurrency, and scalable architectures in Rust 2021+.

Core Features & Use Cases

  • Ownership-based design for safe memory management and zero-cost abstractions.
  • Async and concurrency patterns with tokio, futures, and trait-based APIs for scalable services.
  • Performance optimization, testing discipline, and strong compile-time guarantees with minimal unsafe code.

Quick Start

Provide a minimal Rust module demonstrating memory-safe ownership and async tasks with tokio.

Frequently Asked Questions about rust-engineer

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

FAQPage Schema
How do I design memory-safe Rust applications with robust ownership models?

Design memory-safe Rust applications by structuring ownership and lifetimes to enforce compile-time guarantees. This approach minimizes unsafe code while leveraging zero-cost abstractions for robust memory management.

What is the best way to implement async concurrency in Rust using tokio?

Implement async concurrency in Rust using tokio and futures to build scalable services. Apply trait-based APIs alongside async tasks to handle concurrent operations efficiently without sacrificing safety.

Does this Rust guidance apply to Rust 2021 projects requiring trait-based APIs?

Yes, this guidance specifically applies to Rust 2021 projects requiring trait-based APIs, ownership, and lifetimes. It ensures strong compile-time guarantees and performance optimization across libraries and services.

How do I optimize performance in Rust while keeping unsafe code minimal?

Optimize Rust performance by relying on ownership-based design and zero-cost abstractions to maintain safety. Comprehensive testing, linting, and proper documentation enforce strict compile-time guarantees while minimizing unsafe code.

When do I need to use ownership and lifetimes for systems programming in Rust?

You need ownership and lifetimes for systems programming in Rust when building high-performance software requiring safe memory management. This design prevents memory leaks and data races at compile time.

Can I use tokio and futures to build scalable Rust services with minimal unsafe code?

Yes, you can use tokio and futures to build scalable Rust services with minimal unsafe code. Async concurrency patterns combined with trait-based APIs ensure robust architectures and strong compile-time safety.