rust-skill_skill

Overview

This skill is a Rust programming expert that diagnoses and resolves Rust-specific problems across ownership, lifetimes, concurrency, async/await, and performance. It provides practical fixes, runnable code examples, and guidance tailored to whether you need a learning-oriented explanation or a production-grade solution. Use it to triage compiler errors, design concurrent systems, and optimize real-world Rust projects.

How this skill works

I analyze compiler errors, code snippets, and design descriptions to identify whether issues are language-level (syntax, types, lifetimes) or design-level (architecture, threading, API ergonomics). I propose targeted remedies—borrows vs ownership, Arc vs Rc, lifetimes vs owned types, Send/Sync fixes—and return minimal reproducible code, explanation, and potential pitfalls. I also suggest commands and tooling (cargo check, clippy, fmt, test) and route to specialized capabilities for testing, database, or observability concerns when appropriate.

When to use it

• When you hit Rust compiler errors (ownership, borrow, lifetime diagnostics).
• When designing or debugging concurrent async code with Send/Sync constraints.
• When optimizing performance or eliminating unnecessary clones and allocations.
• When writing or reviewing public APIs and ensuring ergonomic ownership.
• When preparing code for production: testing, safety comments, and diagnostics.

Best practices

• Prefer borrowing (&T) and clear lifetime annotations over moving by default.
• Use ? for error propagation; avoid unwrap() in production code paths.
• Document public APIs with doc comments and annotate unsafe blocks with SAFETY rationale.
• Prefer Arc for shared ownership across threads; replace Rc with Arc in multithreaded contexts.
• Use cargo check/clippy/fmt early in the edit-compile loop to catch issues fast.

Example use cases

• Fixing E0382/E0597 errors by converting moves to borrows or introducing Arc/clone where appropriate.
• Resolving lifetime mismatch errors when returning references from functions or storing references in structs.
• Diagnosing Send/Sync failures by inspecting fields for Rc, Cell, or raw pointers and suggesting thread-safe alternatives.
• Refactoring sync code to async with tokio, ensuring futures are Send when spawned across threads.
• Improving performance by identifying unnecessary allocations, adopting iterator adapters, or adjusting data ownership.