rust-skills

Review Rust code against 179 idiomatic rules for ownership, errors, async, and API design.

142|13|Updated Nov 8, 2025
One-click install
npx skills add https://github.com/noh-rs/nohrs --skill rust-skills-noh-rs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-skills
Source: https://github.com/noh-rs/nohrs/tree/main/.claude/skills/rust-skills
Command: npx skills add https://github.com/noh-rs/nohrs --skill rust-skills-noh-rs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Rust-Skills gives an AI assistant a dense, battle-tested set of rules for writing and reviewing Rust code, reducing ownership mistakes, brittle error handling, async deadlocks, and inconsistent API design.

Core Features & Use Cases

  • Idiomatic Rust guidance: Covers ownership, borrowing, error handling, async patterns, memory optimization, performance, naming, type safety, testing, documentation, project structure, linting, and anti-patterns.
  • Code review support: Helps spot excessive cloning, improper use of Result and panic, lock handling across await points, and missing docs or lints.
  • Design and refactoring help: Useful when creating builders, newtypes, sealed traits, typestate APIs, or cleaner module boundaries in libraries and applications.
  • Performance and reliability focus: Reinforces practical patterns for Tokio, channel selection, allocation reduction, profiling-first optimization, and production-safe Rust workflows.

Quick Start

Ask the assistant to review, refactor, or generate Rust code using the rust-skills guidelines for ownership, errors, async behavior, and API design.

Frequently Asked Questions about rust-skills

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I review Rust code for ownership and async deadlocks?

Review Rust code against 179 idiomatic rules for ownership, errors, async patterns, and API design to catch excessive cloning, improper panics, and lock handling across await points.

What is the best way to handle Result and error propagation in Rust?

Handle Result and error propagation in Rust by applying idiomatic rules for safe error handling, reducing brittle patterns, and ensuring production-ready behavior while preserving safe concurrency.

How do I refactor Rust code to improve API design and module boundaries?

Refactor Rust code by applying guidelines for creating builders, newtypes, sealed traits, and typestate APIs to establish cleaner module boundaries and consistent API design in libraries.

Can I use this to optimize Tokio async performance and reduce allocations?

Yes, you can optimize Tokio async performance and reduce allocations by applying practical patterns for channel selection, profiling-first optimization, and memory reduction in Rust workflows.

Does this Rust code review guidance work for workspace-level projects?

Yes, this Rust code review guidance applies to code generation, refactoring, and review tasks across libraries, applications, and workspace-level Rust projects with varying complexity.

Why should I run clippy and enforce documentation conventions in Rust?

Run clippy and enforce documentation conventions in Rust to identify missing lints, prevent anti-patterns, and maintain idiomatic naming and type safety across your project structure.