rust-engineer/

Rust Разработчик

Опытный Rust-разработчик, создающий высокопроизводительные и безопасные приложения с гарантией отсутствия утечек памяти и данных. Идеально подходит для системного программирования и критически важных задач.

Автор: JeffallanОбновлён Бесплатно

Ставится на компьютере

С телефона скилл не поставить: Claude Code работает на Windows, macOS и Linux. Отправьте ссылку себе и откройте её на компьютере.

Что нужно: компьютер и Claude Code — он работает с подпиской Claude Pro и выше, на бесплатном плане его нет. Как поставить Claude Code →

Карточка

Имя папки
rust-engineer
Автор
Jeffallan
Обновлён
Инструкция
на английском, задачу ставите по-русски
Файлы
  • SKILL.md
  • references/ · 5 файлов

Похожие скиллы

Подобраны по смыслу описания, а не по алфавиту.

  • Разработка
    C++ Профессионал

    Для разработчиков: сложные C++20/23-решения с оптимизацией производительности и памяти

    cpp-pro · Jeffallan

  • Разработка
    Swift Эксперт

    Для разработки iOS/macOS-приложений на Swift 5.9+, SwiftUI и async/await

    swift-expert · Jeffallan

  • Разработка
    Go Разработчик

    Для разработчиков: создание производительных Go-микросервисов и CLI-утилит

    golang-pro · Jeffallan

  • Разработка
    JavaScript Эксперт

    Для разработчиков: сложная логика, оптимизация и асинхронные паттерны на современном JavaScript

    javascript-pro · Jeffallan

  • Разработка
    Apache Spark для больших данных

    Для создания приложений Apache Spark и обработки больших данных

    spark-engineer · Jeffallan

  • Разработка
    Kotlin Специалист

    Для приложений на Kotlin с корутинами, мультиплатформой и Android на Compose.

    kotlin-specialist · Jeffallan

Статьи по теме

Текст инструкции · SKILL.md

Оригинал инструкции (англ.)

Это оригинал автора на английском. Переводить его не нужно: Claude читает инструкцию сам, а задачу вы ставите ему по-русски.

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:

TopicReferenceLoad When
Ownershipreferences/ownership.mdLifetimes, borrowing, smart pointers, Pin
Traitsreferences/traits.mdTrait design, generics, associated types, derive
Error Handlingreferences/error-handling.mdResult, Option, ?, custom errors, thiserror
Asyncreferences/async.mdasync/await, tokio, futures, streams, concurrency
Testingreferences/testing.mdUnit/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 (откроется в новой вкладке)