Coding Guidelines
Install this skill so your agent applies 50 curated Rust naming, formatting, and Clippy-aligned style rules while you write or review backend and systems Rust code.
Overview
coding-guidelines is an agent skill most often used in Build (also Ship review) that applies 50 core Rust Coding Guidelines rules and Clippy-oriented fixes for naming, formatting, and code-review questions.
Install
npx skills add https://github.com/zhanghandong/rust-skills --skill coding-guidelinesWhat is this skill?
- 50 core Rust coding rules distilled from the Huawei Rust Coding Guidelines (P.NAM, G.FMT, safety, and design categories)
- Clippy lint → category → fix mapping for unwrap_used, needless_clone, await_holding_lock, wildcard_imports, and safety l
- Rust-specific naming: no get_ prefix; standard iter / iter_mut / into_iter iterator naming
- Pointers to 500+ full rules on rust-coding-guidelines.github.io and handoff to unsafe-checker for unsafe-related lints
- Keyword triggers for 命名规范, 代码风格, rustfmt, clippy, and code-review questions in Chinese and English
- 50 core Rust coding rules in SKILL.md
- 500+ rules in the full guidelines reference
- 10-row Clippy lint to fix mapping table
Adoption & trust: 1.2k installs on skills.sh; 1.2k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are writing or reviewing Rust and need consistent naming, rustfmt/clippy-aligned fixes, and guideline-backed answers without manually searching a 500+ rule catalog.
Who is it for?
Solo builders maintaining Rust backends, CLIs, or libraries who want agent-assisted code review and style answers tied to established Rust Coding Guidelines and Clippy.
Skip if: Teams only working in non-Rust stacks, or repos where you want zero human/agent style input because CI already enforces every lint with no explanatory layer.
When should I use this skill?
Use when asking about Rust code style or best practices, including naming, formatting, comments, clippy, rustfmt, lint, code review, naming conventions, or Chinese keywords 命名规范, 代码风格, 格式化, 最佳实践, 代码审查, 怎么命名.
What do I get? / Deliverables
Your agent answers style and lint questions with mapped Clippy fixes and Huawei guideline rules, and points you to unsafe-checker when unsafe lints apply.
- Rule-aligned naming and style recommendations
- Clippy lint remediation guidance mapped to guideline categories
- Pointer to unsafe-checker for unsafe-specific lint follow-up
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Rust style and lint guidance lands where solo builders actually author and refactor production Rust—during the Build phase on backend and CLI crates—not as a launch or growth tactic. Backend subphase is the canonical shelf because the rules target module APIs, iterators, async locks, and unsafe-adjacent patterns typical of services, CLIs, and libraries rather than frontend or PM artifacts.
Where it fits
Refactor a service module so public methods drop get_ prefixes and iterator APIs follow iter/into_iter conventions before merging.
Tune an async integration crate after Clippy flags await_holding_lock and you need scoped guard patterns from the mapped fix table.
Walk a PR comment pass using the 50-rule checklist for wildcards, large stack arrays, and undocumented unsafe blocks.
Align test helpers with style rules while interpreting clippy perf lints like linkedlist and needless_clone in test code.
How it compares
Use as a procedural guideline checker in chat, not instead of running cargo clippy and rustfmt in CI.
Common Questions / FAQ
Who is coding-guidelines for?
Solo and indie builders using AI coding agents on Rust crates who want naming, formatting, and Clippy guidance aligned with the public Rust Coding Guidelines reference.
When should I use coding-guidelines?
During Build when naming functions and types or fixing Clippy warnings, and during Ship review when you want rule-backed comments on unwrap, clones, async locks, or imports; also anytime you ask about rustfmt, 命名规范, or 最佳实践 in Rust.
Is coding-guidelines safe to install?
It is documentation and rule-mapping skill content without built-in shell or network actions in SKILL.md; review the Security Audits panel on this Prism page before trusting any third-party skill package.
Workflow Chain
Then invoke: unsafe checker
SKILL.md
READMESKILL.md - Coding Guidelines
# Clippy Lint → Rule Mapping | Clippy Lint | Category | Fix | |-------------|----------|-----| | `unwrap_used` | Error | Use `?` or `expect()` | | `needless_clone` | Perf | Use reference | | `await_holding_lock` | Async | Scope guard before await | | `linkedlist` | Perf | Use Vec/VecDeque | | `wildcard_imports` | Style | Explicit imports | | `missing_safety_doc` | Safety | Add `# Safety` doc | | `undocumented_unsafe_blocks` | Safety | Add `// SAFETY:` | | `transmute_ptr_to_ptr` | Safety | Use `pointer::cast()` | | `large_stack_arrays` | Mem | Use Vec or Box | | `too_many_arguments` | Design | Use struct params | For unsafe-related lints → see `unsafe-checker` skill. # Complete Rules Reference For the full 500+ rules, see: - Source: https://rust-coding-guidelines.github.io/rust-coding-guidelines-zh/ Core rules are in `../SKILL.md`. --- 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.