Index of every page on this site: llms.txt
All skills
jeffallan avatar

/rust-engineer

@67c1961
by jeffallanjeffallan/claude-skills12k stars
1,202
Run it yourself

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.

Use this Skill: https://skilld.dev/gh/jeffallan/claude-skills/rust-engineer

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈156 tokens for metadata: the name and description. ≈1.3k when used: this file. ≈11k more on demand in 5 files.

Description uses 7.8% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈625 characters, or 7.8%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

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

// 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 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, Principal Consultant at Synergetic Solutions

Documentation

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 alert1mo5 checks · Risk CRITICAL
  • Gen Agent Trust Hub1mo

    This skill provides comprehensive, senior-level Rust engineering guidance, including core workflow practices, idiomatic patterns, and detailed references for async programming, error handling, and testing. It uses standard Rust ecosystem tools and crates, and all external references link to official documentation on well-known platforms.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

  • Runlayer8mo

    6 files scanned · No issues

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 67c1961. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 4 days ago.

Activeupdated 2 months ago
Other metadata
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
  • cargo
  • ownership
  • lifetimes
  • async
  • tokio
  • traits
  • error-handling
  • systems-programming
  • memory-safety

README badge

README badge for jeffallan/claude-skills/rust-engineer

Writes, reviews, and debugs idiomatic Rust code with emphasis on ownership patterns, lifetime management, trait design, and async concurrency using tokio. Handles error propagation via Result/Option, validates against clippy and rustfmt, and minimizes unsafe code with documented safety invariants.

Generated from the current SKILL.md.

Does this skill handle async Rust and tokio?
Yes. The skill covers async/await patterns, tokio runtime setup, spawning concurrent tasks, and proper error handling in async contexts. It includes examples of tokio::join! and reqwest integration.
Will this skill write unsafe code?
The skill minimizes unsafe code and requires documentation of safety invariants for every unsafe block. It treats unsafe as a last resort and prefers type-system guarantees.
What error handling approach does this skill use?
The skill uses Result/Option with the ? operator and thiserror for custom error types. It avoids unwrap() in production code in favor of expect() with descriptive messages.
Does this skill validate code before returning it?
Yes. The skill runs cargo clippy, cargo fmt, and cargo test, and fixes all warnings before finalizing.
Can this skill help with lifetime and borrowing issues?
Yes. The skill analyzes ownership relationships, annotates lifetimes explicitly where needed, and designs borrowing patterns to leverage Rust's memory safety without cloning.

Generated from the current SKILL.md. These answers refresh after source changes.