# Rust Engineer

> Writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions. Implements ownership patterns, manages lifetimes, designs trait hierarchies, builds async applications with tokio, and structures error handling with Result/Option. Use when building Rust applications, solving ownership or borrowing issues, designing trait-based APIs, implementing async/await concurrenc…

- **Type:** Skill
- **Install:** `agentstack add skill-jeffallan-claude-skills-rust-engineer`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Jeffallan](https://agentstack.voostack.com/s/jeffallan)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Jeffallan](https://github.com/Jeffallan)
- **Source:** https://github.com/Jeffallan/claude-skills/tree/main/skills/rust-engineer

## Install

```sh
agentstack add skill-jeffallan-claude-skills-rust-engineer
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 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.

## Core Workflow

1. **Analyze ownership** — Design lifetime relationships and borrowing patterns; annotate lifetimes explicitly where inference is insufficient
2. **Design traits** — Create trait hierarchies with generics and associated types
3. **Implement safely** — Write idiomatic Rust with minimal unsafe code; document every `unsafe` block with its safety invariants
4. **Handle errors** — Use `Result`/`Option` with `?` operator and custom error types via `thiserror`
5. **Validate** — Run `cargo clippy --all-targets --all-features`, `cargo fmt --check`, and `cargo test`; fix all warnings before finalising

## 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 |

## Key Patterns with Examples

### Ownership & Lifetimes

```rust
// Explicit lifetime annotation — borrow lives as long as the input slice
fn longest(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// Prefer borrowing over cloning
fn process(data: &[u8]) -> usize {   // &[u8] not Vec
    data.iter().filter(|&&b| b != 0).count()
}
```

### Trait-Based Design

```rust
use std::fmt;

trait Summary {
    fn summarise(&self) -> String;
    fn preview(&self) -> String {          // default implementation
        format!("{}...", &self.summarise()[..50])
    }
}

#[derive(Debug)]
struct Article { title: String, body: String }

impl Summary for Article {
    fn summarise(&self) -> String {
        format!("{}: {}", self.title, self.body)
    }
}
```

### Error Handling with `thiserror`

```rust
use thiserror::Error;

#[derive(Debug, Error)]
pub enum AppError {
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
    #[error("parse error for value `{value}`: {reason}")]
    Parse { value: String, reason: String },
}

// ? propagates errors ergonomically
fn read_config(path: &str) -> Result {
    let content = std::fs::read_to_string(path)?;  // Io variant via #[from]
    Ok(content)
}
```

### Async / Await with Tokio

```rust
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result> {
    let result = fetch_data("https://example.com").await?;
    println!("{result}");
    Ok(())
}

async fn fetch_data(url: &str) -> Result {
    let body = reqwest::get(url).await?.text().await?;
    Ok(body)
}

// Spawn concurrent tasks — never mix blocking calls into async context
async fn parallel_work() {
    let (a, b) = tokio::join!(
        sleep(Duration::from_millis(100)),
        sleep(Duration::from_millis(100)),
    );
}
```

### Validation Commands

```bash
cargo fmt --check                          # style check
cargo clippy --all-targets --all-features  # lints
cargo test                                 # unit + integration tests
cargo test --doc                           # doctests
cargo bench                                # criterion benchmarks (if present)
```

## Constraints

### MUST DO
- Use ownership and borrowing for memory safety
- Minimize unsafe code (document all unsafe blocks with safety invariants)
- Use type system for compile-time guarantees
- Handle all errors explicitly (`Result`/`Option`)
- Add comprehensive documentation with examples
- Run `cargo 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:
1. Type definitions (structs, enums, traits)
2. Implementation with proper ownership
3. Error handling with custom error types
4. Tests (unit, integration, doctests)
5. 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

[Documentation](https://jeffallan.github.io/claude-skills/skills/language/rust-engineer/)

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Jeffallan](https://github.com/Jeffallan)
- **Source:** [Jeffallan/claude-skills](https://github.com/Jeffallan/claude-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-jeffallan-claude-skills-rust-engineer
- Seller: https://agentstack.voostack.com/s/jeffallan
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.