rust-engineer

Guide Rust ownership, lifetimes, traits, and async patterns with tokio.

Updated Apr 15, 2026
One-click install
npx skills add https://github.com/preedep/kham --skill rust-engineer-preedep
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-engineer
Source: https://github.com/preedep/kham/tree/main/.claude/skills/rust-engineer
Command: npx skills add https://github.com/preedep/kham --skill rust-engineer-preedep

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing robust, memory-safe Rust code can be challenging due to ownership, lifetimes, and async complexities. This skill provides a structured approach to designing safe APIs, managing lifetimes, and building reliable asynchronous components with tokio, while also handling errors with Result/Option.

Core Features & Use Cases

  • Ownership and borrowing guidance to craft idiomatic Rust APIs
  • Lifetime management and trait-based API design
  • Async programming patterns using tokio and futures
  • Structured error handling with Result/Option and common crates
  • FFI bindings and zero-cost abstractions for high-performance systems
  • Practical examples for library and application development

Quick Start

Create a small Rust module that demonstrates a safe ownership pattern alongside a tokio-based async function.

Frequently Asked Questions about rust-engineer

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

FAQPage Schema
How do I manage Rust ownership and lifetimes when building async APIs with tokio?

Managing Rust ownership and lifetimes with tokio requires structured guidance on borrowing rules and async patterns. This skill provides practical approaches to design safe APIs, handle lifetime annotations, and build reliable concurrent components using tokio and futures.

What is the best way to handle errors in Rust using Result and Option?

The best way to handle errors in Rust is by leveraging Result and Option for robust error management. This skill offers structured error handling patterns, integrating common crates to ensure safe and reliable execution in Rust libraries and applications.

How do I design trait-based APIs in Rust for zero-cost abstractions?

Designing trait-based APIs in Rust enables zero-cost abstractions by defining shared behavior without runtime overhead. This skill guides you through trait design and lifetime management to craft idiomatic, high-performance Rust components.

Does this Rust guidance cover FFI bindings and high-performance systems?

Yes, this Rust guidance covers FFI bindings and zero-cost abstractions tailored for high-performance systems. It provides practical examples for library and application development requiring memory safety and reliable concurrent patterns.

Why does Rust async programming with tokio cause lifetime compilation errors?

Rust async programming with tokio often causes lifetime errors because futures capture borrowed data across await points. This skill helps solve these complexities by providing structured approaches to ownership, borrowing, and async pattern design.