Engineering RustOwnershipSystems

Rust Engineer

Rust development: ownership, lifetimes, traits, async patterns, error handling with thiserror/anyhow, unsafe code review, and performance-critical system design.

A Rust systems expert who demystifies the borrow checker and translates ownership semantics into productive engineering. Covers async Rust with Tokio, error handling with thiserror and anyhow, trait objects versus generics, zero-copy parsing, and safe patterns for unsafe blocks. Reviews unsafe code for soundness and guides teams from C/C++ or Go to idiomatic Rust.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill rust-engineer

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Explain and resolve borrow checker errors with minimal cloning

Design trait hierarchies and choose between generics and dyn Trait

Build async services with Tokio, Axum, and structured concurrency

Implement error types with thiserror for libraries, anyhow for applications

Review unsafe blocks for soundness and document safety invariants

Optimize hot paths with zero-copy parsing, SIMD hints, and profiling with flamegraph

Real Conversations

See how the Rust Engineer skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

I'm getting 'lifetime may not live long enough' on a struct that holds a &str parsed from an input string. The compiler suggests adding lifetime annotations but I don't understand where.

Agent

When a struct holds a reference, that reference must outlive the struct. You need to annotate the lifetime so the compiler can enforce this:

// ❌ Missing lifetime annotation
struct Config {
    host: &str,
    port: u16,
}

// ✅ Annotate: 'a means "Config cannot outlive the str it borrows from"
struct Config<'a> {
    host: &'a str,
    port: u16,
}

impl<'a> Config<'a> {
    fn new(host: &'a str, port: u16) -> Self {
        Config { host, port }
    }
}

// Works as long as the source string lives longer than config
let input = String::from("localhost");
let config = Config::new(&input, 8080);
// drop(input); // ❌ compiler error: config borrows input

When lifetime annotations are the wrong solution: If this struct is stored in a hashmap, passed across threads, or returned from a function, the lifetime constraint becomes painful. The idiomatic fix is to own the data instead:

struct Config {
    host: String, // owned — no lifetime needed
    port: u16,
}

Use borrowed &str in structs only when you're doing zero-copy parsing (e.g., parsing a large file once and extracting views into it). For most application structs, String ownership is the right default.

You

I wrote an unsafe block to implement a zero-copy ring buffer. The reviewer flagged it but I'm not sure what the unsoundness is. Can you review it?

Agent

Without seeing the code I can walk through the four most common unsoundness patterns in ring buffer implementations:

1. Aliasing mutable references:

// ❌ Creating two &mut references to overlapping memory is UB
let (head, tail) = buf.split_at_mut(mid); // safe split
// Never: &mut buf[i] while another &mut buf[j] exists for i == j

2. Uninitialized memory read:

// ❌ Reading from MaybeUninit without writing first
let val: T = unsafe { slot.assume_init() }; // UB if slot was never written

// ✅ Track initialized slots explicitly
if self.initialized[idx] {
    unsafe { self.slots[idx].assume_init_ref() }
}

3. Missing Send/Sync bounds for shared data:

// If T is not Send, sending the buffer across threads is UB
unsafe impl<T: Send> Send for RingBuffer<T> {}
unsafe impl<T: Send> Sync for RingBuffer<T> {} // only if access is synchronized

4. Non-atomic head/tail counters under concurrent access: Use AtomicUsize with Ordering::Acquire/Release for the read and write indices, or wrap in a Mutex. Relaxed ordering is insufficient for producer-consumer synchronization.

Paste your implementation and I'll identify the specific issue. Including the // SAFETY: comment above your unsafe block explaining your invariants also helps reviewers catch gaps.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Claude Sonnet 4 or GPT-4o handle Rust lifetime reasoning well. Smaller models often produce incorrect lifetime annotations or miss soundness issues in unsafe blocks.

Context Window

SKILL.md ~5KB. Unsafe code reviews and lifetime-heavy generics benefit from 64K+ context to hold full type definitions.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Rust Engineer for end-to-end coverage. Install them together for better results.

Senior Backend

REST APIs, database optimization, authentication, and microservices.

BackendAPIs

Performance Profiler

Node/Python/Go profiling, bundle analysis, and load testing.

PerformanceProfiling

Senior SecOps

Application security, vulnerability management, compliance, and automation.

SecurityCompliance

Code Reviewer

Code review automation for TypeScript, JavaScript, Python, Go, Swift, Kotlin.

ReviewQuality

Senior Architect

System architecture design, dependency analysis, and technical decisions.

ArchitectureDesign

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Rust Engineer?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.