coding-guidelines
actionbook/rust-skills
Reference for Rust code style, naming conventions, and best practices from 50 core rules.
What is coding-guidelines?
A structured guide to Rust-specific coding conventions covering naming, data types, error handling, memory, concurrency, and async patterns. Use this skill when asking about code style, naming conventions, formatting standards, or best practices in Rust projects.
- Provides naming conventions for functions, variables, types, and static items
- Guides data structure choices including newtypes, slices, and pre-allocation strategies
- Explains string handling best practices and performance considerations
- Covers error handling patterns including ? propagation and expect() usage
- Details memory safety practices with lifetimes, RefCell, and shadowing
- Addresses concurrency patterns including lock ordering, atomics, and memory ordering
How to install coding-guidelines
npx skills add https://github.com/actionbook/rust-skills --skill coding-guidelinesHow to use coding-guidelines
- 1.Consult the naming section when designing function or variable names
- 2.Reference the data types table when choosing collection or wrapper types
- 3.Check the deprecated table when encountering older patterns in codebases
- 4.Apply the concurrency rules when designing multi-threaded or async code
- 5.Use the quick reference for formatting and linting setup
Use cases
- Deciding whether to use get_ prefix or direct method names in function design
- Choosing between as_, to_, and into_ for conversion methods
- Selecting appropriate error handling between ? propagation, expect(), and unwrap()
- Determining when to use Cow<str>, String, or &str for string parameters
- Identifying lock ordering issues to prevent deadlocks in concurrent code
- Rust developers writing new code or reviewing existing code
- Teams establishing or enforcing coding standards in Rust projects
- Developers migrating from other languages to Rust conventions
- Contributors to Rust projects following community guidelines
coding-guidelines FAQ
No. Rust convention is to use the property name directly, e.g., fn name() not fn get_name(). The get_ prefix is reserved for fallible accessors that return Option.
Use as_ for cheap conversions that borrow (&), to_ for expensive conversions that may allocate, and into_ for conversions that consume ownership.
Use expect() when the value is guaranteed to be present—it lets you document why. Use unwrap() only for prototyping; expect() is preferred for production code.
Neither. Use std::sync::OnceLock (stable since Rust 1.70) or std::sync::LazyLock (stable since 1.80) instead.
No. Locks held across await can cause deadlocks. Use scoped guards to release locks before awaiting.
Full instructions (SKILL.md)
Source of truth, from actionbook/rust-skills.
name: coding-guidelines description: "Use when asking about Rust code style or best practices. Keywords: naming, formatting, comment, clippy, rustfmt, lint, code style, best practice, P.NAM, G.FMT, code review, naming convention, variable naming, function naming, type naming, 命名规范, 代码风格, 格式化, 最佳实践, 代码审查, 怎么命名" source: https://rust-coding-guidelines.github.io/rust-coding-guidelines-zh/ user-invocable: false
Rust Coding Guidelines (50 Core Rules)
Naming (Rust-Specific)
| Rule | Guideline |
|---|---|
No get_ prefix | fn name() not fn get_name() |
| Iterator convention | iter() / iter_mut() / into_iter() |
| Conversion naming | as_ (cheap &), to_ (expensive), into_ (ownership) |
| Static var prefix | G_CONFIG for static, no prefix for const |
Data Types
| Rule | Guideline |
|---|---|
| Use newtypes | struct Email(String) for domain semantics |
| Prefer slice patterns | if let [first, .., last] = slice |
| Pre-allocate | Vec::with_capacity(), String::with_capacity() |
| Avoid Vec abuse | Use arrays for fixed sizes |
Strings
| Rule | Guideline |
|---|---|
| Prefer bytes | s.bytes() over s.chars() when ASCII |
Use Cow<str> | When might modify borrowed data |
Use format! | Over string concatenation with + |
| Avoid nested iteration | contains() on string is O(n*m) |
Error Handling
| Rule | Guideline |
|---|---|
Use ? propagation | Not try!() macro |
expect() over unwrap() | When value guaranteed |
| Assertions for invariants | assert! at function entry |
Memory
| Rule | Guideline |
|---|---|
| Meaningful lifetimes | 'src, 'ctx not just 'a |
try_borrow() for RefCell | Avoid panic |
| Shadowing for transformation | let x = x.parse()? |
Concurrency
| Rule | Guideline |
|---|---|
| Identify lock ordering | Prevent deadlocks |
| Atomics for primitives | Not Mutex for bool/usize |
| Choose memory order carefully | Relaxed/Acquire/Release/SeqCst |
Async
| Rule | Guideline |
|---|---|
| Sync for CPU-bound | Async is for I/O |
| Don't hold locks across await | Use scoped guards |
Macros
| Rule | Guideline |
|---|---|
| Avoid unless necessary | Prefer functions/generics |
| Follow Rust syntax | Macro input should look like Rust |
Deprecated → Better
| Deprecated | Better | Since |
|---|---|---|
lazy_static! | std::sync::OnceLock | 1.70 |
once_cell::Lazy | std::sync::LazyLock | 1.80 |
std::sync::mpsc | crossbeam::channel | - |
std::sync::Mutex | parking_lot::Mutex | - |
failure/error-chain | thiserror/anyhow | - |
try!() | ? operator | 2018 |
Quick Reference
Naming: snake_case (fn/var), CamelCase (type), SCREAMING_CASE (const)
Format: rustfmt (just use it)
Docs: /// for public items, //! for module docs
Lint: #![warn(clippy::all)]
Claude knows Rust conventions well. These are the non-obvious Rust-specific rules.
Related skills
More from actionbook/rust-skills and the wider catalog.
core-actionbook
Internal support skill for actionbook MCP selectors in Rust documentation research workflows.
core-agent-browser
Internal browser automation CLI for agent workflows requiring interactive page testing and form filling.
core-dynamic-skills
Internal orchestrator for generating and managing Rust crate-specific skills from project dependencies.
core-fix-skill-docs
Internal maintenance tool for checking and fixing Rust skill documentation references.
domain-cli
Build ergonomic CLI tools with type-safe argument parsing, config layering, and user feedback.
domain-cloud-native
Build cloud-native Rust apps with stateless design, graceful shutdown, and observability patterns.