rust-engineer
/rust-engineer
Pisze, recenzuje i debuguje idiomatyczny Rust: wzorce własności, czasy życia, hierarchie cech, aplikacje async z tokio, obsługa błędów, wiązania FFI i optymalizacja wydajności.
- Autor
- Jeffallan ↗
- Repozytorium
- claude-skills ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 25.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 6
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 6
Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Pisze, recenzuje i debuguje idiomatyczny Rust: wzorce własności, czasy życia, hierarchie cech, aplikacje async z tokio, obsługa błędów, wiązania FFI i optymalizacja wydajności.
Oryginalny opis (EN)
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 pro
Jak działa
- Core Workflow
- Reference Guide
- Key Patterns with Examples
- Constraints
- Output Templates
- Knowledge Reference
Podgląd SKILL.md
---
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/)
Pliki w paczce (6)
- SKILL.md 6 KB
- references/async.md 10 KB
- references/error-handling.md 8 KB
- references/ownership.md 6 KB
- references/testing.md 10 KB
- references/traits.md 8 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · Jeffallan/claude-skills | 100 | MIT |
| farm-fe/farm | 100 | MIT |
| seaworld008/commonly-used-high-value-skills | 100 | MIT |
| agentic-swe/agentic-swe | 100 | MIT |
| nasac0x/code-orchestrator | 100 | MIT |
| vathsaskm/rust-programmer | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki df29c9e9cf38 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 95rust-ownership-system
Opisuje system własności w Rust: reguły własności, pożyczanie, lifetimes i bezpieczeństwo pamięci. - 100rust-pro
Pisze nowoczesny kod Rust: własność, async na Tokio, cechy, wydajność i unsafe z FFI dla projektów Cargo. - 90rust-code-expert
Pomaga przy rozwiązaniach w Rust, gdy o wyniku decydują własność, czasy życia, traity, async/Tokio, unsafe, FFI lub Cargo. - 100rust-expert
Wspiera programowanie w Rust na poziomie eksperckim: własność, czasy życia, async, obsługa błędów, system typów i wzorce produkcyjne, w tym programowanie webowe. - 100rust
Opisuje język Rust: własność, pożyczanie, czasy życia, async/await, obsługę błędów i Cargo, z myślą o wydajnych systemach backendowych. - 100rust-expert
Pomaga w Rust przy własności, pożyczaniu, czasie życia, traitach, async i obsłudze błędów, także przy unsafe, Arc i Mutex.