Skip to main content
skill CX Codex

rust-expert-best-practices-code-review — Claude Code skill: Rust rules

rust-expert-best-practices-code-review is a Claude Code skill that guides agents writing, reviewing or refactoring Rust with rules for argument types, error handling, iterators and API design.

MIT 258 installs ★ 9 updated 2026-02-11

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add wispbit-ai/skills --skill rust-expert-best-practices-code-review -a claude-code
Open on GitHub

What rust-expert-best-practices-code-review does

The skill hands the agent a set of Rust conventions. SKILL.md holds the index and priority table, while rules/ keeps one file per habit: take &str rather than &String, propagate failures with ? instead of unwrap, build collections through iterator adapters rather than a loop that pushes.

Each rule file follows the same layout. Why the pattern matters, where it applies and where it does not, then a BAD and a GOOD sample. The agent opens the single file the task needs.

The priority table is what actually steers behaviour. Type safety sits at CRITICAL, performance at MEDIUM, so when two rules pull in different directions the agent keeps the types honest and skips the micro-optimisation. prefer-builder-pattern-for-complex draws its line at functions taking 4+ parameters.

What it helps with

  • swap &String, &Vec<T> and &PathBuf for borrowed argument types
  • move unwrap calls in Result functions to the ? operator
  • replace a push loop with iterator adapters
  • wrap index types so ids from different sources cannot be mixed
  • handle every enum variant in a match instead of a catch-all arm

Example prompts for the agent

  • Review src/parser.rs against the Rust rules and flag every unwrap.
  • Rewrite this function with iterators instead of a push loop.
  • Design the public API for the client module: signatures and error types.

How to install rust-expert-best-practices-code-review

1Skills CLI (Vercel)

npx skills add wispbit-ai/skills --skill rust-expert-best-practices-code-review -a claude-code

2Manually: put the files in place

~/.claude/skills/rust-expert-best-practices-code-review/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/rust-expert-best-practices-code-review/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about rust-expert-best-practices-code-review

How to install rust-expert-best-practices-code-review in Claude Code?

Run npx skills add wispbit-ai/skills --skill rust-expert-best-practices-code-review -a claude-code. The skill lands at ~/.claude/skills/rust-expert-best-practices-code-review/SKILL.md.

What does rust-expert-best-practices-code-review do?

It gives the agent Rust conventions to follow: argument types, Result returns, iterator transforms, builder pattern for long parameter lists. The agent reads the matching file from rules/ before writing code.

Which rules carry the most weight?

Type safety is marked CRITICAL, error handling CRITICAL-HIGH, performance MEDIUM. The full ordering is in the table inside SKILL.md.

Source text

SKILL.md · MIT
---
name: rust-expert-best-practices-code-review
description: Rust best practices and code quality guidelines for writing idiomatic, safe, and performant Rust code. This skill should be used when writing, reviewing, or refactoring Rust code. Triggers on tasks involving Rust programming, code review, error handling, type safety, or performance optimization.
license: MIT
metadata:
  author: wispbit
  version: "1.0.0"
---

# Rust Expert Best Practices

Simple, pragmatic, opinionated. Only what matters for writing production-grade Rust code.

## When to Apply

Reference these guidelines when:
- Writing Rust code (structs, functions, enums, traits)
- Implementing error handling and Result types
- Reviewing Rust code for safety or performance issues
- Refactoring existing Rust codebases
- Designing APIs and public interfaces
- Optimizing Rust code for performance or clarity

## Rule Categories by Priority

| Priority | Category | Impact | Prefix |
|----------|----------|--------|--------|
| 1 | Type Safety | CRITICAL | `use-typesafe-`, `use-enum-` |
| 2 | Error Handling | CRITICAL-HIGH | `result-`, `avoid-panic` |
| 3 | API Design | HIGH | `use-borrowed-`, `prefer-builder-` |
| 4 | Code Quality | MEDIUM-HIGH | `use-iterator-`, `prefer-format` |
| 5 | Readability | MEDIUM | `use-named-`, `avoid-boolean-` |
| 6 | Performance | MEDIUM | `avoid-rc`, `avoid-box` |

## Quick Reference

- `use-borrowed-argument-types` - Use &str, &[T], &Path instead of &String, &Vec<T>, &PathBuf
- `use-enum-deserialization` - Use exhaustive enum matching for safe deserialization
- `use-typesafe-index-wrappers` - Wrap index types to prevent mixing different indices
- `result-error-returns` - Use ? operator instead of unwrap/expect in Result functions
- `avoid-panic` - Use assert!, Result, or expect based on context instead of panic!
- `use-iterator-transforms` - Use iterator methods instead of explicit push loops
- `use-copied` - Use .copied() to avoid complex dereferencing patterns
- `prefer-format` - Use format! over manual string concatenation
- `prefer-builder-pattern-for-complex` - Use builder pattern for functions with 4+ parameters
- `use-named-placeholders` - Use named placeholders instead of bare _ in destructuring
- `decimal-comparison` - Use .is_sign_negative() instead of comparing to Decimal::ZERO
- `calculated-field-as-method` - Implement calculated fields as methods not struct fields
- `avoid-rc` - Avoid unnecessary Rc<T> when simpler ownership patterns work
- `avoid-box` - Don't use Box<T> for concrete types without legitimate reason
- `avoid-boolean-params` - Replace boolean parameters with enums or structs
- `match-statements-handle-all-cases` - Explicitly handle all enum variants without catch-all patterns

## How to Use

Read individual rule files for detailed explanations and code examples:

```
rules/use-borrowed-argument-types.md
rules/use-enum-deserialization.md
rules/use-typesafe-index-wrappers.md
rules/result-error-returns.md
rules/avoid-panic.md
rules/use-iterator-transforms.md
rules/use-copied.md
rules/prefer-format.md
rules/prefer-builder-pattern-for-complex.md
rules/use-named-placeholders.md
rules/decimal-comparison.md
rules/calculated-field-as-method.md
rules/avoid-rc.md
rules/avoid-box.md
rules/avoid-boolean-params.md
rules/match-statements-handle-all-cases.md
```

Each rule file contains:
- Brief explanation of why it matters
- When to use and when not to use the pattern
- Implementation requirements
- BAD code examples with explanation
- GOOD code examples with explanation
- Additional context and best practices

© wispbit · MIT · wispbit-ai/skills

Similar skills

All skills for Code review and refactoring →

From the same set5

Project sponsors

Companies that keep this analytics open