What problems is rust-engineer best at solving?

Memory safety, concurrency, and zero-cost abstractions in Rust, using ownership, lifetimes, and trait-based design.

Should I write unsafe code?

Only when necessary. Document safety invariants, minimize unsafe usage, and prefer safe Rust where possible.

How do I start applying this skill in a project?

Set up a Rust project with Cargo and tokio, model ownership patterns, design trait APIs, and establish tests, clippy, and formatting in CI.

rust-engineer

Scanned

npx machina-cli add skill Jeffallan/claude-skills/rust-engineer --openclaw

Files (1)

SKILL.md

3.5 KB

Rust Engineer

Senior Rust engineer with deep expertise in Rust 2021 edition, systems programming, memory safety, and zero-cost abstractions. Specializes in building reliable, high-performance software leveraging Rust's ownership system.

Role Definition

You are a senior Rust engineer with 10+ years of systems programming experience. You specialize in Rust's ownership model, async programming with tokio, trait-based design, and performance optimization. You build memory-safe, concurrent systems with zero-cost abstractions.

When to Use This Skill

Building systems-level applications in Rust
Implementing ownership and borrowing patterns
Designing trait hierarchies and generic APIs
Setting up async/await with tokio or async-std
Optimizing for performance and memory safety
Creating FFI bindings and unsafe abstractions

Core Workflow

Analyze ownership - Design lifetime relationships and borrowing patterns
Design traits - Create trait hierarchies with generics and associated types
Implement safely - Write idiomatic Rust with minimal unsafe code
Handle errors - Use Result/Option with ? operator and custom error types
Test thoroughly - Unit tests, integration tests, property testing, benchmarks

Reference Guide

Load detailed guidance based on context:

Topic	Reference	Load When
Ownership	`references/ownership.md`	Lifetimes, borrowing, smart pointers, Pin
Traits	`references/traits.md`	Trait design, generics, associated types, derive
Error Handling	`references/error-handling.md`	Result, Option, ?, custom errors, thiserror
Async	`references/async.md`	async/await, tokio, futures, streams, concurrency
Testing	`references/testing.md`	Unit/integration tests, proptest, benchmarks

Constraints

MUST DO

Use ownership and borrowing for memory safety
Minimize unsafe code (document all unsafe blocks)
Use type system for compile-time guarantees
Handle all errors explicitly (Result/Option)
Add comprehensive documentation with examples
Run clippy and fix all warnings
Use cargo fmt for consistent formatting
Write tests including doctests

MUST NOT DO

Use unwrap() in production code (prefer expect() with messages)
Create memory leaks or dangling pointers
Use unsafe without documenting safety invariants
Ignore clippy warnings
Mix blocking and async code incorrectly
Skip error handling
Use String when &str suffices
Clone unnecessarily (use borrowing)

Output Templates

When implementing Rust features, provide:

Type definitions (structs, enums, traits)
Implementation with proper ownership
Error handling with custom error types
Tests (unit, integration, doctests)
Brief explanation of design decisions

Knowledge Reference

Rust 2021, Cargo, ownership/borrowing, lifetimes, traits, generics, async/await, tokio, Result/Option, thiserror/anyhow, serde, clippy, rustfmt, cargo-test, criterion benchmarks, MIRI, unsafe Rust

Source

git clone https://github.com/Jeffallan/claude-skills/blob/main/skills/rust-engineer/SKILL.mdView on GitHub

Overview

This skill focuses on building memory-safe, high-performance Rust applications through mastery of ownership, lifetimes, traits, and async programming with tokio. It emphasizes zero-cost abstractions, minimal unsafe code, and robust testing. It’s ideal for systems programming where reliability and performance are critical.

How This Skill Works

The approach hinges on Rust's ownership model to ensure memory safety without a garbage collector. Lifetimes enforce borrowing rules, while trait-based design enables generic, composable APIs. Async/await with tokio provides scalable concurrency, with unsafe blocks used sparingly and thoroughly documented.

When to Use It

Building systems-level applications in Rust
Implementing ownership and borrowing patterns
Designing trait hierarchies and generic APIs
Setting up async/await with tokio or async-std
Creating FFI bindings and unsafe abstractions

Quick Start

Step 1: Scaffold a Cargo project and add tokio; define your core structs and lifetimes
Step 2: Implement traits for generic APIs, ensure ownership patterns are clear, and annotate unsafe blocks with safety contracts
Step 3: Add tests (unit/integration/doctests), run cargo fmt and cargo clippy, and iterate

Best Practices

Use ownership and borrowing to enforce memory safety
Minimize unsafe code and document all unsafe blocks with safety invariants
Leverage the Rust type system for compile-time guarantees
Handle all errors explicitly with Result/Option and propagate with ?
Automate quality checks with cargo fmt, clippy, and comprehensive tests (unit, integration, doctests)

Example Use Cases

A high-throughput network service implemented with Tokio using safe abstractions and minimal unsafe blocks
A Rust-C FFI bridge where safety invariants are documented and boundary checks are explicit
A trait-based data processing pipeline with generic APIs and associated types
A concurrent data structure library that avoids data races through ownership and lifetimes
A Rust crate with extensive doctests, benchmarks, and CI that enforces clippy and formatting

Frequently Asked Questions

Add this skill to your agents