review-rust-code

Automates Rust code reviews to enforce idiomatic patterns and best practices via static analysis.

1|Updated Jan 25, 2026
One-click install
npx skills add https://github.com/datastx/Feather-Flow --skill review-rust-code
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-rust-code
Source: https://github.com/datastx/Feather-Flow/tree/main/.claude/skills/review-rust-code
Command: npx skills add https://github.com/datastx/Feather-Flow --skill review-rust-code

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a structured, automated approach to reviewing Rust code, ensuring adherence to idiomatic patterns, robust error handling, and safe async practices, reducing code debt and onboarding time.

Core Features & Use Cases

  • Pattern-driven reviews: Enforces type-driven design, explicit error propagation with ?, and minimal visibility to prevent leaking internals.
  • Quality guidance: Identifies common Rust anti-patterns, unsafe blocks, and missing tests, and suggests concrete improvements.
  • Use Case: When reviewing a Rust project, run the review to produce actionable feedback for maintainers, new contributors, or during refactors.

Quick Start

Run the Rust code review on your project by pointing the tool at the src/ and tests/ directories to generate a prioritized list of recommended changes.

Frequently Asked Questions about review-rust-code

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

FAQPage Schema
How do I automate a Rust code review for idiomatic patterns?

Automate a Rust code review by pointing a static analysis tool at your src/ and tests/ directories to generate a prioritized list of recommended changes enforcing type-driven design and minimal visibility.

What are common Rust anti-patterns found during a code audit?

Common Rust anti-patterns identified during a code audit include unnecessary unsafe blocks, missing tests, non-idiomatic error propagation, and lacking trait-based abstractions across modules and async paths.

How do I enforce explicit error handling and early returns in Rust?

Enforce explicit error handling and early returns in Rust by applying static analysis rules that require the ? operator for error propagation and mandate type-driven design across project crates.

Does this Rust review approach work for async paths and refactoring?

Rust review for async paths and refactoring works by analyzing crates and modules to enforce safe async practices, robust error handling, and idiomatic patterns, reducing code debt and onboarding time.

Can I use this Rust code review during project onboarding?

You can use this Rust code review during project onboarding to produce actionable feedback for new contributors, ensuring they adhere to idiomatic patterns, minimal visibility, and explicit error handling.