Beautiful Rust
Three Agent Skills and a tested clippy config that teach coding agents to write, review, and port idiomatic Rust.
- Source repo
- morganlinton/BeautifulRust
- Stars
- ★ 1.7k
- Last updated
- 2d ago
- License
- MIT
- Primary language
- Python
- FA score
- 78/100 · Good
At a glance
- How it runs
- Works with
- Universal · cross-platformChatGPT · Codex · Claude Code · Claude.ai
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- Engineers writing Rust libraries with Claude Code or Codex who want private fields, # Errors docs, and copy-safe doc examples by default
- Not a fit if
- Teams whose coding agents do not read the Agent Skills format
- Developers who do not write or port Rust
- Source review
- 78/100 · Good
What does this agent do, and when should you use it?
Beautiful Rust (morganlinton/BeautifulRust) is a set of skills in the Agent Skills format plus a lints configuration. It ships three skills: rust-best-practices loads whenever an agent writes or changes Rust and steers it toward idiomatic, robust code; rust-review reviews a file, crate, or diff and writes a prioritized report where every finding cites the rule it breaks and shows the fix; rust-port ports C, C++, Python, Go, or JavaScript to Rust with identical behavior, porting the original tests first so the two can be proven to match. The lints/ directory provides a drop-in clippy configuration for CI, with every lint verified to fire against a deliberately violating crate. The guidance is distilled from five sources — Google Rust Style Guide, Rust API Guidelines, Effective Rust, Rust Design Patterns, and Microsoft Pragmatic Rust Guidelines — plus a Bevy 0.20-specific exception reference. It installs via a Claude Code plugin, a Codex plugin, the npx skills installer, or by copying folders, and works with Claude Code, Codex, Copilot, Cursor, Gemini CLI, or any agent that reads the format.
Once installed, the three skill folders (skills/rust-best-practices, skills/rust-review, skills/rust-port) are read by the agent automatically: while coding, rust-best-practices guides generation through 13 sections (ownership, type and API design, errors, async, unsafe, etc.); when reviewing, rust-review runs cargo fmt, clippy, and the tests when a toolchain is available, then produces a three-tier report (must fix / should fix / consider) with file:line locations, rule provenance (e.g. C-GETTER, an Effective Rust item, a clippy lint), and the smallest fix; when porting, rust-port ports tests first, designs a Rust API rather than transliterating, verifies with cargo test and clippy, and emits a PORTING.md mapping old and new APIs. When a crate depends on bevy, both the writing and review skills read references/bevy.md first to preserve Bevy conventions and flag silently compiling ECS bugs like B0001. Copying lints/clippy.toml and the [lints] block from lints/lints.toml, then running cargo clippy --all-targets --all-features -- -D warnings enforces the rules in CI; lints/check/ proves every lint fires via a crate with one deliberate violation per lint.
- Engineers writing Rust libraries with Claude Code or Codex who want private fields, # Errors docs, and copy-safe doc examples by default
- Maintainers reviewing a Rust file, crate, or PR diff who want a tiered report with rule provenance and minimal fixes
- Teams porting C, C++, Python, Go, or JavaScript modules to Rust who want tests ported first and behavior verified
- Bevy or bevy_ecs developers who need the skill to recognize conventions like by-value system parameters and prelude imports
- Teams wanting clippy in CI to flag unwrap() outside tests, unsafe without SAFETY comments, reason-less #[allow], and similar patterns
How do you install or deploy this agent?
Multiple install paths are documented.
Any agent, one command (requires Node 22.20+):
npx skills add morganlinton/BeautifulRustClaude Code plugin (updates with one command):
claude plugin install beautiful-rust --marketplace morganlinton/BeautifulRustOpenAI Codex plugin:
codex plugin marketplace add morganlinton/BeautifulRust
codex plugin add beautiful-rust@beautiful-rustGitHub Copilot (requires GitHub CLI 2.90+):
gh skill install morganlinton/BeautifulRust rust-best-practices
gh skill install morganlinton/BeautifulRust rust-review
gh skill install morganlinton/BeautifulRust rust-portGemini CLI:
gemini skills install https://github.com/morganlinton/BeautifulRust --path skills/rust-best-practices
gemini skills install https://github.com/morganlinton/BeautifulRust --path skills/rust-review
gemini skills install https://github.com/morganlinton/BeautifulRust --path skills/rust-portCursor or anything else — clone and copy the skill folders:
git clone https://github.com/morganlinton/BeautifulRust
mkdir -p ~/.agents/skills
cp -R BeautifulRust/skills/rust-* ~/.agents/skills/Note: Claude Code does not read .agents/skills/ — use its own directory or the plugin. For claude.ai, zip each skill folder and upload under Customize > Skills with code execution enabled.
How do you use this agent?
Skills trigger on their own; you rarely need to invoke them explicitly (they appear as /beautiful-rust:rust-best-practices etc. in Claude Code).
Reviewing code: ask your agent, e.g. "review src/parser.rs" or "what would you change in this PR".
Porting code: ask, e.g. "port parser.c to Rust" or "rewrite this Python service in Rust".
Enforcing rules in CI: copy lints/clippy.toml next to your Cargo.toml, paste the [lints] block from lints/lints.toml, then run:
cargo clippy --all-targets --all-features -- -D warningsVerify the lint config (from the repo root):
bash scripts/check-lints.shRun skill evals (real, billed model runs):
claude plugin eval . --allow-tools Write,Edit,Bash --scaffoldWhat are this agent's strengths and limitations?
- Every code example compiles on stable Rust and every lint is proven to fire via the lints/check/ crate with one deliberate violation each — not an arbitrary rule list
- In the October 2026 blind-graded benchmark, Claude Code improved from 85% to 94% and Codex from 62% to 89%, with full method and caveats published
- Works across five mainstream agents (Claude Code, Codex, Copilot, Cursor, Gemini CLI) with a clear table of install paths per agent
- Where the five sources disagree, the skill picks a side and says why; a Bevy 0.20 reference covers by-value system params, prelude imports, and silently compiling ECS bugs like B0001
- Effectiveness depends on the host agent; Claude actually did worse on the Bevy feature task with the skills, and gains vary by agent and task
- rust-review and rust-port rely on a local Rust toolchain (cargo, clippy); without one, functionality is limited
- The benchmark was one run per configuration, graded by a Claude model — limited evidence strength
- Copilot and Gemini CLI require installing all three skills individually; Gemini CLI only supports per-path installs, not a full plugin
How does this agent compare with similar options?
The repo does not name direct competitors, but its benchmark compares Claude Code (Opus 5.5) and Codex CLI with and without the skills, which serves as a gauge of expected benefit.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Beautiful Rust This agent | 78 · Good | Agent plugin / skillFree + model costs | ★ 1.7k | 2d ago | Python | ChatGPT · Codex · Claude Code · Claude.ai |
| Waza | 63 · Some gaps | CLIFree | ★ 7.5k | 3d ago | Python | Codex · Claude Code |
| Aster | 77 · Good | CLIFree + model costs | ★ 137 | 4d ago | Rust | OpenAI API |
| Finding-Unknowns Skills | 76 · Good | Agent plugin / skillFree | ★ 363 | 1mo ago | Python | Claude Code · Claude.ai |
How does FollowAgents rate this agent?
Why each dimension lost points
The product is prompt-content skills with no network access or credential handling; the review skill runs cargo fmt/clippy/tests, disclosed in the README — reasonable scope, so least_privilege is 2. Running cargo test on untrusted code under review requires no explicit user confirmation, so user_confirmation is 1. PRIVACY.md exists and the website-notify workflow documents its secret use and skip behavior, so data_flow_transparency is 2. sensitive_data_handling rests only on the existence of PRIVACY.md, whose contents are not in evidence: 1. No runtime dependencies, but install goes through a third-party npx installer: dependency_security 2. External effects (toolchain execution, Vercel hook) are disclosed: 2. The attribution table lists authors and licenses per source, source_attribution 3.
Three CI workflows validate skill manifests, compile every example, and prove each lint fires; check-skill.py has ~40 unit tests including a self-check of the real repo: self_consistency 3. Requires cargo, python3, Node 22.20+; some version floors given but no full dependency matrix: dependency_availability 2. Checker error messages are asserted in tests (file:line, drift hints, skip-reason rule): failure_messages 3.
Covers writing, reviewing, and porting across many agents: audience_and_scenarios 3. Limits are honestly documented — a dedicated Bevy reference, one benchmark case where skills hurt, a separate caveats page: capability_boundaries 3. Triggering relies on SKILL.md descriptions ('loads whenever an agent writes Rust'); full frontmatter not in evidence: trigger_precision 2. Environment fit is excellent, including the Claude Code .agents/skills quirk: environment_fit 3.
A full annotated directory tree: information_architecture 3. Install notes cover six agents, claude.ai zips, and a directory table: install_notes 3. Names are consistent and machine-enforced (folder/name match, semver): naming_stability 3. Rich examples but no FAQ: examples_and_faq 2. Limitations well disclosed (benchmark caveats, rust-version floor, Bevy exceptions): known_limitations 3. MIT with LICENSE file: license 3. CHANGELOG, enforced semver consistency, documented release flow: versioning_changelog 3. CONTRIBUTING and update paths exist, but a single unverified maintainer with no cadence or response commitment: maintenance_responsibility 2.
Review output has three tiers, file:line locations, rule citations, minimal fixes, and a strengths close; ports ship PORTING.md: output_usability 3. Marginal value is backed by 29/30 vs 24/30 and a cross-agent benchmark, but these are self-reported, model-graded, one run per configuration: marginal_value 2. Cost is just prompt text plus a lints file; however one negative result is admitted and grading is model-based: cost_benefit 2.
Every rule must trace to a published source; examples are compile-checked per block; lints proven to fire via a violation crate: claim_traceability 3. Five external sources with licenses are checkable, but digests are paraphrases whose fidelity cannot be verified in static review: cross_source_corroboration 2. Facts and inference are mostly separated (benchmark caveats, 'the crab is a crab'), yet headline claims (all lints fire, all examples compile) are self-assertions within this evidence set: fact_inference_separation 2.
- The rust-review skill runs cargo fmt/clippy/test, i.e., executes the code under review; sandbox before auditing untrusted code.
- Installation goes through a third-party npx installer and per-agent plugin marketplaces — supply-chain steps outside this repo's control.
- Effectiveness claims (29/30, cross-agent benchmark) are self-reported, model-graded, one run per configuration; treat as unverified.
- Publisher identity is unverified; the lints need rust-version 1.81+, and Bevy support is pinned to 0.20 — recheck on upgrades.
- This static review did not read SKILL.md bodies, lints/lints.toml, or eval content; trigger precision and rule quality were not item-by-item verified.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
v1.5.0 v1.5.0: Bevy, and a benchmark across agents
Release notes excerpt
Bevy support, a Claude Code vs Codex benchmark, and every Rust example compiled in CI. Thanks to @tmchow and @DylanCosto for their pull requests, and to @millionart for proposing Bevy support. Bevy support A new [Bevy 0.20 reference](https://github.com/morganlinton/BeautifulRust/blob/main/skills/rust-best-practices/references/bevy.md) teaches the skills which general Rust rules don't fit Bevy systems (by-value system parameters, the prelude, plain-data components, complex queries) and which ECS bugs compile cleanly but fail at runtime: two queries that can reach the same comp …View on GitHub ↗ -
v1.4.0 v1.4.0: every rule, checked
Release notes excerpt
The first BeautifulRust release with outside contributions. Huge thanks to @mvanhorn, who sent both of this release's headline features. Every lint is now proven to fire lints/check/ is a small crate with one deliberate violation for each of the 28 lints in the drop-in config, and scripts/check-lints.sh runs clippy on it. It fails if a lint goes quiet, if anything unexpected fires, or if the published table drifts from the tested one. CI runs it on every push and pull request, so the lints config can't silently rot. …View on GitHub ↗ -
v1.3.0 v1.3.0: port your code to Rust
Release notes excerpt
BeautifulRust now ports existing code to Rust, and the repo is ready for contributors. New: the rust-port skill Ask your agent to port a module ("port parser.c to Rust", "rewrite this Python service in Rust") and it: - reads the original and its tests, and ports the tests first, so the port is proven against the original's own behavior …View on GitHub ↗