skills.rest
austintheriot
austintheriotCOMMUNITY
Explore all skills by this author →
GitHub

rust-review

Review Rust diffs for idiomatic design, safety, and footguns.

1|Updated Jul 31, 2023
Search Tags:#code review#rust#safety audit#idiomatic design#async correctness#unsafe soundness#api critique
One-click install
npx skills add https://github.com/austintheriot/dotfiles --skill rust-review-austintheriot
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: rust-review
Source: https://github.com/austintheriot/dotfiles/tree/main/.claude/skills/rust-review
Command: npx skills add https://github.com/austintheriot/dotfiles --skill rust-review-austintheriot

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you catch subtle Rust issues in design, safety, and language-specific footguns that compilers and linters often miss, so you can ship changes with confidence.

Core Features & Use Cases

  • Diff-focused Rust review: Reviews the current branch against main by default, or targets a specific path, PR number, or git range.
  • Specialist routing by change type: Automatically routes hunks to rust-async, rust-unsafe, rust-wasm, rust-ffi, or rust-backend subagents based on what changed.
  • Actionable severity findings: Produces severity-labeled findings with file:line references, without posting external comments.
  • Use cases: soundness audits, idiomatic design critique, type/API evaluation, and expert guidance on changed Rust code.

Quick Start

Ask for a review by saying: Review my Rust changes from PR 123 for idiomatic design, safety, and Rust-specific footguns, and report severity-labeled findings with file and line references.

Frequently Asked Questions about rust-review

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

FAQPage Schema
How do I review Rust code for safety issues that rustc and clippy miss?▼

You can review Rust code by analyzing branch-vs-main diffs, specific paths, PR numbers, or git ranges to identify idiomatic design flaws, unsafe soundness, and Rust-specific footguns with severity-labeled findings.

What's the best way to audit unsafe Rust blocks for soundness?▼

Auditing unsafe Rust for soundness is handled by routing unsafe code hunks to specialist subagents that evaluate memory safety risks, producing severity-labeled findings with precise file and line references.

How do I check async Rust code for correctness and idiomatic design?▼

Checking async Rust for correctness involves routing async code hunks to a dedicated subagent that evaluates concurrency footguns and idiomatic design, yielding severity-labeled, file:line-referenced output.

Can I review a specific pull request for Rust API critique and footguns?▼

Yes, you can review a specific pull request for API critique by providing the PR number, which triggers a diff-focused review targeting idiomatic design, type/API evaluation, and Rust-specific footguns without posting external comments.

Does this Rust code review tool work with FFI and WebAssembly changes?▼

Yes, this Rust code review tool works with FFI and WebAssembly changes by automatically routing relevant code hunks to specialized subagents for targeted safety and design evaluation.

How do I exclude generated files from a Rust code safety audit?▼

You can exclude generated files from a Rust code safety audit by specifying optional exclusions for irrelevant artifacts, ensuring the review focuses only on meaningful source code changes within the selected diff or git range.

Related Skills

Explore More Software Engineering Skills→
Let-s-internLet-s-intern
8

code-review

Review code changes across pull requests and local git diffs.

Official
Advanced
austintheriotaustintheriot
1

ts-review

Review TypeScript diffs for type-design and type-safety issues.

Community
Advanced
trailofbitstrailofbits
6.5k

rust-review

Audit Rust code for security vulnerabilities across unsafe, concurrency, and FFI boundaries.

Official
Advanced
VenTheZoneVenTheZone
42

specialist-rust-reviewer

Identify ownership, borrowing, and memory-safety issues in modified Rust files.

Community
Intermediate