Prototype · Preview: every server in the official registry, synced every 30 minutes. Sign in with Google to write reviews.Prototype · updated every 30 min
PopNx MCPMCP servers for people who use AI · explained in plain words

BeautifulRust Skill

by morganlinton★ 1,8261 skills

Install

What it does

Agent Skills that teach coding agents to write, review, and port idiomatic Rust, plus a tested clippy config. Works with Claude Code, Codex, Copilot, Cursor, and Gemini CLI.

  • Connects Instruction files the AI reads; connects to nothing
  • Account or key No key needed
  • Category Coding
For makers: add a badge to your README

If you made this, paste this code into your README. The badge links back to this page.

[![Featured on PopNx MCP](https://mcp.popnx.com/badge/skill/morganlinton-beautifulrust.svg)](https://mcp.popnx.com/en/skills/morganlinton-beautifulrust)

Use together with

MCP servers that connect the AI to services for the same work

REA

Reverse engineer anything from your terminal or agent with one CLI and MCP server.

by morlutoWidely used↓ 388.7K/wk★ 461.8KUpdated 4 days ago

MCP · Connects a serviceRuns on your computer

Fallow

Codebase intelligence for TypeScript and JavaScript, exposed as structured MCP analysis tools.

by fallow-rsWidely used↓ 2.4M/wk★ 5.4KUpdated yesterday

MCP · Connects a serviceRuns on your computer

Desktop Commander

MCP server for terminal commands, file operations, and process management

by wonderwhy-erWidely used↓ 740.3K/wk★ 10.3KUpdated 4 days ago

MCP · Connects a serviceRuns on your computer

Similar Skills

Same kind of work, ordered like the Skills list

Compared with similar ones
This one
BeautifulRust
reagraphifyarchifysecurity-audit-skill
MakermorganlintonmorlutoGraphify-Labstt-a1icloudflare
Skills11111
GitHub stars1,826461,751148,35296,75773,156
Last code changeNov 9, 2026Nov 16, 2026Nov 16, 2026Nov 15, 2026Sep 15, 2026
LicenseMITMITApache-2.0Apache-2.0MIT

1 skills (instruction sets) by morganlinton that an AI reads and follows · not an MCP server

How a Skill differs from MCP

MCP = the hands

Connects the AI to an outside service or data, such as reading Notion or creating an invoice. A program or server has to be running.

Skill = the manual

A text file that teaches the AI how to do a task. It connects to nothing.

Some overlap: a few Skills run scripts that call tools, and a few MCP servers only send knowledge. Start from the task you want done.

Works with

Claude CodeClaude (เว็บ/แอป)CodexCursorGemini CLIGitHub Copilot

From the maker’s README and the folders in the repo

Install

Is it safe?

  • Who made it

    GitHub account morganlinton (person), 8 years old

  • Use and upkeep

    ★ 1,826 stars · code last changed Nov 9, 2026

  • Any scripts?

    5 scripts that can run on a computer: evals/bevy-arena-regen/place-files.sh, evals/refactor-inventory-module/place-files.sh, evals/bevy-arena-regen/files/src/lib.rs, evals/bevy-arena-regen/files/tests/arena.rs and 1 more

  • Uses the internet?

    No internet calls found in the scripts

  • Changes machine-wide settings?

    No hooks or writes to machine settings found

Checked automatically from the repo files at commit b971843 (read only, nothing was run). Not a safety guarantee: read it and decide for yourself

First: which AI do you use?

Pick your app and this page shows only how to install it there

Option 1Upload to claude.ai (web and app)

Uploading to claude.ai would fail: the description is over 200 characters (593). Use "Let the AI install it" instead

Option 1Let Claude Code install it

Copy this sentence and paste it into a Claude Code chat

Where to install

Checking the commands · copy buttons appear once they pass

Checking the commands · copy buttons appear once they pass

For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing

The AI tells you what it will do first and asks your permission at every step

Restart Claude Code, then type /rust-best-practices or ask for a matching task and Claude picks it up

Checked against official docs Nov 12, 2026 · Source: code.claude.com

For Terminal users

A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.

The maker’s recommended way

Install Node.js (if you don’t have it)

Already installed? Check first · Open Terminal, type this command and press Enter

node -v
  • A version number such as v26.13.1 = installed, skip this step
  • "command not found" (on Windows: "is not recognized") = not installed yet, or installed but Terminal needs to be closed and reopened
How to open Terminal

Mac: press ⌘ + Space, type Terminal, press Enter

Windows: open Start, type Windows PowerShell, then Open

Not installed: Open the official download page, pick the LTS version and the click-through installer: .pkg on Mac · .msi on Windows. Double-click and follow it to the end. No curl command needed

Open the Node.js download page ↗

When it’s done, close Terminal, open it again and run the same command. You should see a version number: node -v

Install once; it works for everything that needs Node.js

Checking the commands · copy buttons appear once they pass

Copied from the maker’s README; it downloads and runs the maker’s code

  1. Open Terminal

    Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead

  2. Copy the skill folder to ~/.claude/skills

    This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md

    Checking the commands · copy buttons appear once they pass

  3. Restart Claude Code, then type /rust-best-practices or ask for a matching task and Claude picks it up

Skills you install yourself work in the ChatGPT desktop app, Codex CLI and the Codex IDE extension · ChatGPT on the web and mobile cannot use skills you install yourself, only skills that come with a plugin from the directory

ChatGPT desktop app

The ChatGPT desktop app has Codex built in, and Codex reads skills from ~/.agents/skills

Option 1Let ChatGPT install it

Open Codex in the ChatGPT desktop app and paste this sentence into the chat

Where to install

Checking the commands · copy buttons appear once they pass

Checking the commands · copy buttons appear once they pass

The AI always shows you the path before installing

The AI tells you what it will do first and asks your permission at every step

Option 2Put the folder there yourself

Put the rust-best-practices folder at ~/.agents/skills/rust-best-practices

~ is your home folder ($HOME)

For Terminal users

A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.

  1. Open Terminal

    Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead

  2. Copy the skill folder to ~/.agents/skills

    This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md

    Checking the commands · copy buttons appear once they pass

After installing

  • ChatGPT desktop app: open Skills in the sidebar to see that the skill is there
  • To use it: in ChatGPT type @ and pick the skill · in Codex CLI or the IDE extension run /skills or type $ and the skill name
  • Codex picks up newly installed skills by itself; if one does not show up, restart Codex

Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com

ChatGPT on the web and mobile

Skills you install yourself do not work here; only skills that come with a plugin from the directory

To use this skill with ChatGPT, use the ChatGPT desktop app as above

Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com

Option 1Let Codex install it

Copy this sentence and paste it into a Codex chat · Works in Codex inside the ChatGPT desktop app, Codex CLI and the IDE extension

Where to install

Checking the commands · copy buttons appear once they pass

Checking the commands · copy buttons appear once they pass

For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing

The AI tells you what it will do first and asks your permission at every step

Codex picks up newly installed skills by itself; if one does not show up, restart Codex · To use it: in ChatGPT type @ and pick the skill · in Codex CLI or the IDE extension run /skills or type $ and the skill name

Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com

For Terminal users

A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.

  1. Open Terminal

    Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead

  2. Copy the skill folder to ~/.agents/skills

    This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md

    Checking the commands · copy buttons appear once they pass

  3. Restart Codex, then ask for a matching task; Codex lists the skill

Option 1Let Cursor install it

Copy this sentence and paste it into a Cursor chat

Where to install

Checking the commands · copy buttons appear once they pass

Checking the commands · copy buttons appear once they pass

For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing

The AI tells you what it will do first and asks your permission at every step

In Cursor’s Agent chat, type / and pick rust-best-practices

Checked against official docs Nov 12, 2026 · Source: cursor.com

For Terminal users

A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.

  1. Open Terminal

    Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead

  2. Copy the skill folder to ~/.cursor/skills

    This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md

    Checking the commands · copy buttons appear once they pass

  3. In Cursor’s Agent chat, type / and pick rust-best-practices

Option 1Let the AI install it

For other apps that read skills. The sentence gives the paths for Claude Code, Codex and Cursor so the AI picks the one for your app · Copy this sentence into the app’s chat

Where to install

Checking the commands · copy buttons appear once they pass

Checking the commands · copy buttons appear once they pass

For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing

The AI tells you what it will do first and asks your permission at every step

Checked against official docs Nov 12, 2026 · Source: code.claude.com, learn.chatgpt.com, cursor.com

For Terminal users

Other apps that support Agent Skills (such as Gemini CLI or GitHub Copilot) use different folders. Check that app’s guide, then copy the folder with the SKILL.md there.

View on GitHub ↗

Skill folders checked against the official Claude Code, Codex and Cursor guides on Nov 11, 2026

View the original SKILL.md

The text below comes from the maker’s repo, not from PopNx MCP

Showing the first 8,000 characters · Open the full file on GitHub

---
name: rust-best-practices
description: >-
  Write idiomatic, robust, maintainable Rust. Use this skill whenever you write, review,
  refactor, debug, or explain Rust code: new crates, modules, functions, structs, traits,
  error types, async code, unsafe or FFI code, Cargo.toml, tests, or rustdoc. Trigger on
  any mention of Rust, cargo, crates, .rs files, the borrow checker, lifetimes, traits,
  clippy, or rustfmt, even when the user does not ask for "best practices" or "idiomatic"
  code. Synthesized from the Google Rust Style Guide, the Rust API Guidelines,
  Effective Rust, Rust Design Patterns, and Microsoft's Pragmatic Rust Guidelines.
---

# Rust best practices

Distilled from five Rust style and design guides, with a digest of each in `references/`.
Where they disagree, this file says which to follow and why.

## 1. Mindset

- **Write Rust-shaped code.** Don't port C++, Java, C#, or Python constructs one-to-one.
  Model errors with `Result`, resources with ownership and `Drop`, polymorphism with
  traits and enums, and nullability with `Option`. Inheritance-flavored tricks (`Deref` to
  a "base" struct, `Manager`/`Factory` types, `throw_if_null` helpers) are smells.
- **Make invalid states unrepresentable.** Push invariants into types: enums instead of
  bool flags and "must be X if Y" comments, newtypes for units and IDs, fallible
  constructors that validate once. Then the compiler enforces what a comment only requests.
- **Application code is not library code.** Library code (anything with external users)
  follows the API-design rules below strictly. Application code should favor simplicity
  and directness: concrete types, `String` or `&str` rather than `impl Into<String>`
  parameters, `anyhow`-style errors, `Vec` return values, no speculative generality.
- **Let the tools do the work.** rustfmt owns formatting, clippy owns idiom checks, the
  compiler owns memory safety. Spend your attention on design.

## 2. Before you hand back code

Run these and fix everything they report:

```bash
cargo fmt
cargo clippy --all-targets --all-features -- -D warnings
cargo test
cargo doc --no-deps   # libraries: catches broken doc links and missing docs
```

- Fix a lint rather than silencing it. When a lint is genuinely wrong for one item, use
  `#[expect(clippy::name, reason = "...")]` on the narrowest item. `expect` warns when
  the lint stops firing, so stale suppressions get cleaned up. Use `#[allow]` only in
  generated code or macro output.
- Never put `#![deny(warnings)]` in source: new toolchains add warnings and break the
  build. Enforce warnings-as-errors in CI instead, with `cargo clippy -- -D warnings`.
- Configure lints once in `Cargo.toml` (`[lints]` or `[workspace.lints]`), not with
  scattered crate attributes. If a project has none, suggest `lints/lints.toml` and
  `lints/clippy.toml` from https://github.com/morganlinton/BeautifulRust; the suppression
  lints in it need `rust-version` 1.81 or later.

## 3. Ownership and borrowing

**Prefer unique ownership.** Reach for `Rc`/`Arc` only when shared ownership is part of
the design, and for `RefCell`/`Mutex` only when interior mutability is. They are not
failures, but they move checking from compile time to run time, so use them on purpose.

**Don't clone to make the borrow checker stop complaining.** A clone that exists only to
end a borrow produces a silent copy whose later changes are lost. Try these first, in
roughly this order:

1. Extend a temporary with a named `let`, or shorten a borrow with a block.
2. Split a long expression into typed intermediates so the failing step is visible.
3. Move a field out of `&mut self` with `std::mem::take` (needs `Default`),
   `std::mem::replace`, or `Option::take` instead of cloning it.
4. Split a large struct into smaller ones so disjoint fields can be borrowed separately.
   The compiler tracks disjoint field borrows inside one function, but not across
   method calls.
5. Clone small, immutable data deliberately, and say so in a comment if it's not obvious.
6. Use indices into an owning `Vec`, or `Rc<RefCell<_>>` with `Weak` back-pointers, as
   a last resort. Avoid self-referential structs.

```rust
// Move out of a &mut enum without cloning.
fn a_to_b(e: &mut MyEnum) {
    if let MyEnum::A { name, x: 0 } = e {
        *e = MyEnum::B { name: std::mem::take(name) };
    }
}
```

**Accept the most general borrowed type.** `&str` not `&String`, `&[T]` not `&Vec<T>`,
`&T` not `&Box<T>`, `Option<&T>` not `&Option<T>`. Deref coercion then lets callers pass
owned values, borrows, or literals. Where you only read a path, string, or byte buffer,
`impl AsRef<Path>` / `impl AsRef<str>` / `impl AsRef<[u8]>` is fine on parameters (never
on struct fields; store `PathBuf` and `String`). Library code that only iterates should
take `impl IntoIterator<Item = T>`; application code may simply take `&[T]`.

**Take ownership only when you need it, and then take it by value.** If a function stores
or consumes its argument, take `T`, not `&T` plus an internal `.clone()`. If it only
reads, take `&T`; if it mutates in place, `&mut T`. Return multiple values as a tuple or
struct, not through `&mut` out-parameters (reusing a caller-owned buffer, as
`Read::read` does, is the exception).

**Prefer owned data in structs.** A struct holding `&'a T` forces a lifetime onto every
container. Owning a `String` or `Vec<u8>` is usually simpler and rarely the bottleneck.
When a type does carry a lifetime, give it a descriptive name (`'src`, `'conn`); `'_` and
`'a` are fine on simple functions.

**Freeze after setup.** Build with `let mut`, then rebind `let data = data;` so later
code cannot mutate it by accident.

**Keep `Rc`, `Arc`, `Box`, and `RefCell` out of public signatures.** Take `&T`,
`&mut T`, or `T` and let callers decide how to own things. A service that must be shared
implements a cheap `Clone` by wrapping its state in `Arc<Inner>` internally.

## 4. Types and API design

### Naming

| Item | Case | Notes |
|---|---|---|
| Types, traits, enum variants | `UpperCamelCase` | Acronyms are one word: `Uuid`, `HttpClient` |
| Functions, methods, modules, locals | `snake_case` | |
| Constants, statics | `SCREAMING_SNAKE_CASE` | |
| Type parameters | short, from the main bound | `T`, `R: Read`, `W: Write` |
| Lifetimes | short lowercase | descriptive when on a type |

- No `get_` prefix on getters: `fn len(&self)`, `fn name(&self) -> &str`,
  `fn name_mut(&mut self)`. Use bare `get` only when there is one obvious thing to get
  (`Cell::get`). Related: `set_foo(T)`, `take_foo()`, `with_foo(|f| ..)` for closure
  access, and unsafe `_unchecked` siblings for checked accessors.
- Conversion prefixes signal cost and ownership: `as_` (free, borrow to borrow), `to_`
  (expensive, borrow to owned or borrow to borrow), `into_` (consumes `self`). Put `mut`
  in type order: `as_mut_slice`, not `as_slice_mut`.
- Constructors: `new` (primary), `with_capacity` / `new_with_foo` (variants), `try_new`
  (fallible), `from_foo` (conversion; pair important ones with a `From` impl). I/O
  resources use domain verbs: `File::open`, `TcpStream::connect`.
- `iter` / `iter_mut` / `into_iter` return types named `Iter` / `IterMut` / `IntoIter`;
  `keys()` returns `Keys`.
- Error types read verb-object-error: `ParseBoolError`, not `BoolParseError`.
- Avoid weasel suffixes `Service`, `Manager`, `Factory`, `Helper`, `Util`. Name the thing
  it is (`Bookings`, `Dispatcher`, `FooBuilder`). Don't repeat the module name in the
  type (`foo::Id`, not `foo::FooId`). Avoid abbreviations an outsider wouldn't know.
- If you implement `len()`, implement `is_empty()`.
- Feature names are bare: `std`, `serde`, `alloc`, never `use-std` or `no-std`.

### Model the domain with types

- **Newtypes** for semantic distinctions: `struct Miles(f64)` and `struct Kilometers(f64)`
  cannot be mixed, where a type alias can. Add `#[repr(transparent)]` when layout matters,
  and derive or forward the traits you need (`derive_mo

Discussion

Ask, share a tip or report that it does not work. Sorted by what people marked helpful.

No posts yet. Be the first to ask or share.

Posts here are written by users, not the PopNx team.

Sign in to post

From GitHub

GitHub stars
1,826
Maker
morganlinton
License
MIT
Last code change
Nov 9, 2026
SKILL.md files in the repo (including translated copies and templates)
1
Topics
agent-skills, claude-code, claude-plugin, claude-skills, clippy, code-review, coding-agent, cursor, rust, style-guide