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 Ru
Install
npx skills add https://github.com/Jeffallan/claude-skills/tree/main/skills/rust-engineer
claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install jeffallan-claude-skills@llmmart
git clone https://github.com/Jeffallan/claude-skills.git
The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole jeffallan/claude-skills collection as a plugin from our marketplace. Git is the plain clone.
Skill manifest
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
- Analyze ownership — Design lifetime relationships and borrowing patterns; annotate lifetimes explicitly where inference is insufficient
- Design traits — Create trait hierarchies with generics and associated types
- Implement safely — Write idiomatic Rust with minimal unsafe code; document every
unsafeblock with its safety invariants - Handle errors — Use
Result/Optionwith?operator and custom error types viathiserror - Validate — Run
cargo clippy --all-targets --all-features,cargo fmt --check, andcargo 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
// Explicit lifetime annotation — borrow lives as long as the input slice
fn longest<'a>(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<u8>
data.iter().filter(|&&b| b != 0).count()
}
Trait-Based Design
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
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<String, AppError> {
let content = std::fs::read_to_string(path)?; // Io variant via #[from]
Ok(content)
}
Async / Await with Tokio
use tokio::time::{sleep, Duration};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let result = fetch_data("https://example.com").await?;
println!("{result}");
Ok(())
}
async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
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
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 clippyand fix all warnings - Use
cargo fmtfor consistent formatting - Write tests including doctests
MUST NOT DO
- Use
unwrap()in production code (preferexpect()with messages) - Create memory leaks or dangling pointers
- Use
unsafewithout documenting safety invariants - Ignore clippy warnings
- Mix blocking and async code incorrectly
- Skip error handling
- Use
Stringwhen&strsuffices - 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
Maintained by @jeffallan, Principal Consultant at Synergetic Solutions
Files (claude-skills)
-
references
-
async.md 10.4 KB
Loading… -
error-handling.md 7.9 KB
Loading… -
ownership.md 5.9 KB
Loading… -
testing.md 9.6 KB
Loading… -
traits.md 7.6 KB
Loading…
-
-
SKILL.md 6 KB
--- name: rust-engineer description: 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 concurrency, creating FFI bindings, or optimizing for performance and memory safety. Invoke for Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming. license: MIT metadata: author: https://github.com/Jeffallan company: https://synergetic.solutions version: "1.1.0" domain: language triggers: Rust, Cargo, ownership, borrowing, lifetimes, async Rust, tokio, zero-cost abstractions, memory safety, systems programming role: specialist scope: implementation output-format: code related-skills: test-master --- # 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<'a>(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<u8> 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<String, AppError> { 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<(), Box<dyn std::error::Error>> { let result = fetch_data("https://example.com").await?; println!("{result}"); Ok(()) } async fn fetch_data(url: &str) -> Result<String, reqwest::Error> { 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 Maintained by [@jeffallan](https://github.com/jeffallan), Principal Consultant at [Synergetic Solutions](https://synergetic.solutions) [Documentation](https://jeffallan.github.io/claude-skills/skills/language/rust-engineer/)
Comments (0)
Sign in to join the conversation.
Reviews (0)
No reviews yet.
No comments yet.