Install
Terminal · npx$
npx skills add https://github.com/jeffallan/claude-skills --skill rust-engineerWorks with Paperclip
How Rust Engineer fits into a Paperclip company.
Rust Engineer drops into any Paperclip agent that handles this kind of work. Assign it to a specialist inside a pre-configured PaperclipOrg company and the skill becomes available on every heartbeat — no prompt engineering, no tool wiring.
S
SaaS FactoryPaired
Pre-configured AI company — 18 agents, 18 skills, one-time purchase.
$27$59
Explore packSource file
SKILL.md167 linesExpandCollapse
---name: rust-engineerdescription: 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: MITmetadata: author: https://github.com/Jeffallan 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 insufficient2. **Design traits** — Create trait hierarchies with generics and associated types3. **Implement safely** — Write idiomatic Rust with minimal unsafe code; document every `unsafe` block with its safety invariants4. **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 slicefn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y }} // Prefer borrowing over cloningfn process(data: &[u8]) -> usize { // &[u8] not Vec<u8> data.iter().filter(|&&b| b != 0).count()}``` ### Trait-Based Design ```rustuse 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` ```rustuse 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 ergonomicallyfn 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 ```rustuse 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 contextasync fn parallel_work() { let (a, b) = tokio::join!( sleep(Duration::from_millis(100)), sleep(Duration::from_millis(100)), );}``` ### Validation Commands ```bashcargo fmt --check # style checkcargo clippy --all-targets --all-features # lintscargo test # unit + integration testscargo test --doc # doctestscargo 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 ownership3. Error handling with custom error types4. 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