What is Beautiful Rust?
Beautiful Rust is Agent Skills that teach coding agents to write, review and port idiomatic Rust. A `lints/` folder holds a drop-in clippy configuration that enforces the machine-checkable rules in CI. It sits in the Agent Skills & Plugins category of the Agents & Automation tools and is open-source, written in Python and licensed MIT.
Overview
Beautiful Rust is a package of three Agent Skills plus a lints configuration for one job: getting coding agents to produce idiomatic Rust. `rust-best-practices` loads whenever an agent writes or changes Rust code; `rust-review` reviews a file, crate or diff and writes a prioritised report; `rust-port` ports C, C++, Python, Go or JavaScript to Rust with the same behaviour. A `lints/` folder holds a drop-in clippy configuration that enforces the machine-checkable rules in CI.
The guidance is distilled from five published sources — the Google Rust Style Guide, the official Rust API Guidelines, Effective Rust, Rust Design Patterns and Microsoft's Pragmatic Rust Guidelines — with a condensed digest of each bundled inside the skill so the agent can look up the reasoning. Where the sources disagree, the skill picks a side and says why. Every code example compiles on stable Rust, and a dedicated reference covers Bevy, whose ECS conventions contradict some general Rust advice.
Because the skills use the standard Agent Skills format, they work in Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI and other agents that read it, and the repository doubles as a Claude Code and Codex plugin marketplace. It ships its own eval cases; the project's October 2026 run, graded blind by a Claude model with one run per configuration, reports Claude Code going from 85% to 94% of checks with the skills and Codex CLI from 62% to 89%. It is licensed MIT.
What it does
- `rust-best-practices`: a ~500-line writing skill covering ownership, API design, errors, idioms, concurrency, unsafe/FFI, crates, docs, tests and performance
- `rust-review`: runs fmt, clippy and tests when available, then reports must-fix / should-fix / consider findings with a file:line, the rule's source and the smallest fix
- `rust-port`: ports C, C++, Python, Go or JavaScript by porting the tests first, designing a Rust API rather than transliterating, and writing a PORTING.md
- A clippy lints table — no `unwrap()` outside tests, `// SAFETY:` on every unsafe block, reasons on `#[allow]`, `# Errors` / `# Panics` docs — with a check crate proving each lint fires
- A Bevy reference that tells the agent which Bevy conventions to leave alone and which ECS bugs compile cleanly
- Installs as a Claude Code or Codex plugin, via `npx skills`, `gh skill` or `gemini skills`, or by copying folders into `.agents/skills/`
Getting started
Install all three skills — the review and port skills rely on the best-practices skill for style. The universal installer needs Node 22.20 or later.
Install for any agent with one command
The `skills` installer puts the skill folders where most agents look. Add `-g` for a user-wide install, or `-a <agent>` (for example `-a codex` or `-a cursor`) to pick an agent.
npx skills add morganlinton/BeautifulRustOr install it as a Claude Code plugin
The skills then appear as `/beautiful-rust:rust-best-practices`, `/beautiful-rust:rust-review` and `/beautiful-rust:rust-port`, though they trigger on their own.
claude plugin install beautiful-rust --marketplace morganlinton/BeautifulRustOr as a Codex plugin
The same package also works in the ChatGPT desktop app.
codex plugin marketplace add morganlinton/BeautifulRust
codex plugin add beautiful-rust@beautiful-rustAsk for a review or a port
Prompt the agent normally, for example "review src/parser.rs" or "port parser.c to Rust"; the matching skill loads itself and produces a tiered review report or a tested port with a PORTING.md.
Enforce the rules in CI
Copy `lints/clippy.toml` next to your `Cargo.toml`, paste the `[lints]` block from `lints/lints.toml` into it, then run clippy with warnings as errors.
cargo clippy --all-targets --all-features -- -D warningsCommands and code are distilled from the project's own documentation — always check the official repo for the latest.
When to use it
- Stopping an agent from shipping public fields, undocumented errors and `unwrap()` in Rust library code
- Getting a prioritised, source-cited review of a Rust crate or pull request
- Porting a C or Python module to Rust with the original tests carried over to prove the behaviour matches
- Keeping agent-written Rust in a Bevy game from breaking ECS conventions
How Beautiful Rust compares
Beautiful Rust alongside other open-source agent skills & plugins tools AI/TLDR tracks, ranked by GitHub stars.
| Tool | Stars | What it does |
|---|---|---|
| Superpowers | ★ 311k | A composable skills plugin that installs a spec-first, TDD, subagent-driven development methodology into Claude Code, Codex, Cursor, Gemini CLI and other coding harnesses. |
| Skills for Real Engineers | ★ 309k | Matt Pocock's everyday agent skills for coding agents, covering alignment grilling, planning, code review and research — small, composable and meant to be edited. |
| ECC | ★ 295k | An installable plugin that adds 68 agents, 286 skills, hooks, rules, memory and an agent-config security scanner to Claude Code, Codex and other coding harnesses. |
| Karpathy Coding Guidelines | ★ 228k | A Claude Code plugin and CLAUDE.md rule set built from Andrej Karpathy's observations on LLM coding pitfalls: think before coding, keep it simple, make surgical changes, and work to verifiable success criteria. |
| Ponytail | ★ 182k | A skill and plugin that makes a coding agent take the laziest correct route — a seven-rung ladder from "does this need to exist?" to "the minimum that works" — while keeping validation, security and accessibility off the chopping block. |
| Caveman | ★ 117k | A skill plus local proxy that shortens an AI coding agent's prose while leaving code, commands and paths untouched — the rule file cuts what the agent writes, the proxy compresses what it reads. |
| Addy’s Agent Skills | ★ 112k | A pack of production engineering skills for AI coding agents, with nine lifecycle slash commands — /spec, /plan, /build, /test, /review, /ship — installable into 70+ agents. |
| Beautiful Rust | ★ 1.6k | Agent Skills that teach coding agents to write, review and port idiomatic Rust |