Skip to content
Back to search

beautiful-rust

MarketplaceWorks with Claude CodeGitHub

Skills for writing beautiful, idiomatic Rust with Claude.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/morganlinton--beautifulrust/badge.svg)](/listings/morganlinton--beautifulrust)

HTML

<a href="/listings/morganlinton--beautifulrust"><img src="/api/listings/morganlinton--beautifulrust/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Each skill is a folder under `skills/`: `rust-best-practices/`, `rust-review/`, and `rust-port/`. Every option below puts those folders where your agent looks for skills. Install all three; the review and port skills lean on the best-practices skill for style.

Any agent, one command

The [`skills`](https://github.com/vercel-labs/skills) installer supports most agents (Node 22.20 or later):

npx skills add morganlinton/BeautifulRust

Add `-g` to install for your user instead of the current project, or `-a <agent>` to pick an agent, such as `-a codex` or `-a cursor`.

Claude Code

Install it as a plugin so updates arrive with one command:

claude plugin install beautiful-rust --marketplace morganlinton/BeautifulRust

Inside a session, the same thing is:

/plugin marketplace add morganlinton/BeautifulRust
/plugin install beautiful-rust@beautiful-rust

This installs all three skills. They appear as `/beautiful-rust:rust-best-practices`, `/beautiful-rust:rust-review`, and `/beautiful-rust:rust-port`, though you rarely need to call them, since they trigger on their own. To try it for one session without installing, clone the repo and run `claude --plugin-dir ./BeautifulRust`.

GitHub Copilot

With GitHub CLI 2.90 or later:

gh skill install morganlinton/BeautifulRust rust-best-practices
gh skill install morganlinton/BeautifulRust rust-review
gh skill install morganlinton/BeautifulRust rust-port

This installs into the current project by default. Add `--scope user` to install for your user, or `--agent <name>` to install for a different agent.

Gemini 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-port

OpenAI Codex, Cursor, or anything else: copy the folder

Clone the repo and copy the three skill folders into your agent's skills directory. Most agents now read the shared `.agents/skills/` location:

git clone https://github.com/morganlinton/BeautifulRust
mkdir -p ~/.agents/skills
cp -R BeautifulRust/skills/rust-* ~/.agents/skills/

| Agent | User directory | Project directory | |---|---|---| | Claude Code | `~/.claude/skills/` | `.claude/skills/` | | OpenAI Codex | `~/.agents/skills/` | `.agents/skills/` | | GitHub Copilot | `~/.copilot/skills/` or `~/.agents/skills/` | `.github/skills/` or `.agents/skills/` | | Cursor | `~/.cursor/skills/` or `~/.agents/skills/` | `.cursor/skills/` or `.agents/skills/` | | Gemini CLI | `~/.gemini/skills/` or `~/.agents/skills/` | `.gemini/skills/` or `.agents/skills/` |

Claude Code does not read `.agents/skills/`, so use its own directory or the plugin. Restart the agent if the skill doesn't show up right away.

claude.ai

claude.ai takes one zip per skill, with the skill folder as the zip root:

cd skills
zip -r ../rust-best-practices.zip rust-best-practices -x '*.DS_Store' -x '*/evals/*'
zip -r ../rust-review.zip rust-review -x '*.DS_Store' -x '*/evals/*'
zip -r ../rust-port.zip rust-port -x '*.DS_Store' -x '*/evals/*'

Upload each under **Customize > Skills**. Code execution must be enabled first.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "beautiful-rust",
  3. "owner": {
  4. "name": "Morgan Linton",
  5. "url": "https://github.com/morganlinton"
  6. },
  7. "description": "Skills for writing beautiful, idiomatic Rust with Claude.",
  8. "plugins": [
  9. {
  10. "name": "beautiful-rust",
  11. "source": "./",
  12. "description": "Skills that teach Claude to write, review, and port idiomatic Rust, distilled from five authoritative guides, plus a drop-in clippy config."
  13. }
  14. ]
  15. }
README.md · README · 451 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="assets/banner.png" alt="Pixel art banner: a crab on rocky tide pools at sunset, with waves, sea stacks, and a forested headland, under the title Beautiful Rust and the subtitle Idiomatic Rust, distilled">
  3. </p>
  4. # Beautiful Rust
  5. Three standard [Agent Skills](https://agentskills.io) and a lints config that teach coding
  6. agents to write, review, port, and enforce idiomatic Rust:
  7. - **`rust-best-practices`** loads whenever an agent writes or changes Rust, and steers it
  8. toward idiomatic, robust, maintainable code.
  9. - **`rust-review`** reviews existing Rust code, a file, a crate, or a diff, and writes a
  10. prioritized report where every finding cites the rule it breaks and shows the fix.
  11. - **`rust-port`** ports C, C++, Python, Go, or JavaScript to idiomatic Rust with the same
  12. behavior, porting the original tests first so you can prove the two match.
  13. - **`lints/`** is a drop-in clippy configuration that enforces the machine-checkable rules
  14. in CI.
  15. They work with Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, and any other
  16. agent that reads the Agent Skills format. Every code example in the skills compiles on
  17. stable Rust, and every lint in the config was checked against current clippy.
  18. The guidance is distilled from five sources, with a condensed digest of each bundled in
  19. the skill so the agent can consult the original reasoning when it needs to:
  20. - [Google Rust Style Guide](https://google.github.io/styleguide/rustguide.html)
  21. - [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/) (official rust-lang checklist)
  22. - [Effective Rust](https://www.lurklurk.org/effective-rust/) by David Drysdale
  23. - [Rust Design Patterns](https://rust-unofficial.github.io/patterns/) (idioms, patterns, anti-patterns)
  24. - [Microsoft Pragmatic Rust Guidelines](https://microsoft.github.io/rust-guidelines/)
  25. Where the sources disagree, the skill picks a side and says why.
  26. ## What it changes
  27. Asked for a small semver-parsing library, an agent without the skill produced working
  28. code with public fields, no `# Errors` docs, and `unwrap()` in its doc examples. With the
  29. skill, the same agent kept the fields private, documented failure modes, and wrote doc
  30. examples users can copy safely. Condensed from those two runs:
  31. ```rust
  32. // Without the skill
  33. /// A semantic version. The fields are public for convenience.
  34. pub struct Version {
  35. pub major: u64,
  36. pub minor: u64,
  37. pub patch: u64,
  38. pub pre: Vec<Identifier>,
  39. pub build: Vec<String>,
  40. }
  41. impl Version {
  42. /// Parses a version string.
  43. ///
  44. /// ```
  45. /// let v = Version::parse("1.2.3").unwrap();
  46. /// ```
  47. pub fn parse(s: &str) -> Result<Version, ParseError> { /* ... */ }
  48. }
  49. ```
  50. ```rust
  51. // With the skill
  52. /// A semantic version. Equality, hashing, and ordering ignore build metadata.
  53. pub struct Version {
  54. major: u64,
  55. minor: u64,
  56. patch: u64,
  57. pre: Vec<Identifier>,
  58. build: Vec<String>,
  59. }
  60. impl Version {
  61. /// Parses a version string according to SemVer 2.0.0.
  62. ///
  63. /// # Errors
  64. ///
  65. /// Returns [`ParseVersionError`] if the string is empty, a numeric part has a
  66. /// leading zero or overflows `u64`, or an identifier contains invalid characters.
  67. ///
  68. /// ```
  69. /// # use semver_lite::Version;
  70. /// # fn main() -> Result<(), semver_lite::ParseVersionError> {
  71. /// let v = Version::parse("1.2.3-beta.1")?;
  72. /// assert_eq!(v.major(), 1);
  73. /// # Ok(())
  74. /// # }
  75. /// ```
  76. pub fn parse(s: &str) -> Result<Self, ParseVersionError> { /* ... */ }
  77. /// Returns the major version number.
  78. pub fn major(&self) -> u64 { self.major }
  79. }
  80. ```
  81. Across three test tasks (a library, a CLI, and refactoring a messy module), the skill
  82. passed 29 of 30 checks against 24 of 30 without it. See [Testing the skills](#testing-the-skills).
  83. ## Install
  84. Each skill is a folder under `skills/`: `rust-best-practices/`, `rust-review/`, and
  85. `rust-port/`. Every option below puts those folders where your agent looks for skills.
  86. Install all three; the review and port skills lean on the best-practices skill for style.
  87. ### Any agent, one command
  88. The [`skills`](https://github.com/vercel-labs/skills) installer supports most agents
  89. (Node 22.20 or later):
  90. ```bash
  91. npx skills add morganlinton/BeautifulRust
  92. ```
  93. Add `-g` to install for your user instead of the current project, or `-a <agent>` to pick
  94. an agent, such as `-a codex` or `-a cursor`.
  95. ### Claude Code
  96. Install it as a plugin so updates arrive with one command:
  97. ```bash
  98. claude plugin install beautiful-rust --marketplace morganlinton/BeautifulRust
  99. ```
  100. Inside a session, the same thing is:
  101. ```
  102. /plugin marketplace add morganlinton/BeautifulRust
  103. /plugin install beautiful-rust@beautiful-rust
  104. ```
  105. This installs all three skills. They appear as `/beautiful-rust:rust-best-practices`,
  106. `/beautiful-rust:rust-review`, and `/beautiful-rust:rust-port`, though you rarely need to
  107. call them, since they trigger on their own. To try it for one session without installing, clone the repo
  108. and run `claude --plugin-dir ./BeautifulRust`.
  109. ### OpenAI Codex
  110. Install it as a plugin:
  111. ```bash
  112. codex plugin marketplace add morganlinton/BeautifulRust
  113. codex plugin add beautiful-rust@beautiful-rust
  114. ```
  115. This installs all three skills as `beautiful-rust:rust-best-practices`,
  116. `beautiful-rust:rust-review`, and `beautiful-rust:rust-port`. The same package works in
  117. the ChatGPT desktop app.
  118. ### GitHub Copilot
  119. With GitHub CLI 2.90 or later:
  120. ```bash
  121. gh skill install morganlinton/BeautifulRust rust-best-practices
  122. gh skill install morganlinton/BeautifulRust rust-review
  123. gh skill install morganlinton/BeautifulRust rust-port
  124. ```
  125. This installs into the current project by default. Add `--scope user` to install for your
  126. user, or `--agent <name>` to install for a different agent.
  127. ### Gemini CLI
  128. ```bash
  129. gemini skills install https://github.com/morganlinton/BeautifulRust --path skills/rust-best-practices
  130. gemini skills install https://github.com/morganlinton/BeautifulRust --path skills/rust-review
  131. gemini skills install https://github.com/morganlinton/BeautifulRust --path skills/rust-port
  132. ```
  133. ### Cursor or anything else: copy the folder
  134. Clone the repo and copy the three skill folders into your agent's skills directory.
  135. Most agents now read the shared `.agents/skills/` location:
  136. ```bash
  137. git clone https://github.com/morganlinton/BeautifulRust
  138. mkdir -p ~/.agents/skills
  139. cp -R BeautifulRust/skills/rust-* ~/.agents/skills/
  140. ```
  141. | Agent | User directory | Project directory |
  142. |---|---|---|
  143. | Claude Code | `~/.claude/skills/` | `.claude/skills/` |
  144. | OpenAI Codex | `~/.agents/skills/` | `.agents/skills/` |
  145. | GitHub Copilot | `~/.copilot/skills/` or `~/.agents/skills/` | `.github/skills/` or `.agents/skills/` |
  146. | Cursor | `~/.cursor/skills/` or `~/.agents/skills/` | `.cursor/skills/` or `.agents/skills/` |
  147. | Gemini CLI | `~/.gemini/skills/` or `~/.agents/skills/` | `.gemini/skills/` or `.agents/skills/` |
  148. Claude Code does not read `.agents/skills/`, so use its own directory or the plugin.
  149. Restart the agent if the skill doesn't show up right away.
  150. ### claude.ai
  151. claude.ai takes one zip per skill, with the skill folder as the zip root:
  152. ```bash
  153. cd skills
  154. zip -r ../rust-best-practices.zip rust-best-practices -x '*.DS_Store' -x '*/evals/*'
  155. zip -r ../rust-review.zip rust-review -x '*.DS_Store' -x '*/evals/*'
  156. zip -r ../rust-port.zip rust-port -x '*.DS_Store' -x '*/evals/*'
  157. ```
  158. Upload each under **Customize > Skills**. Code execution must be enabled first.
  159. ## Reviewing existing code
  160. Ask your agent to review a file, crate, or diff, for example "review src/parser.rs" or
  161. "what would you change in this PR". The `rust-review` skill runs `cargo fmt`, `clippy`, and
  162. the tests when a toolchain is available, then writes a report with three tiers: must fix,
  163. should fix, and consider. Every finding gives a `file:line` location, the rule it breaks
  164. with its source (an API Guidelines code such as `C-GETTER`, an Effective Rust item, a
  165. Microsoft guideline, or a clippy lint), and the smallest code change that fixes it. Each
  166. report ends with what the code already does well.
  167. [`examples/review-inventory.md`](examples/review-inventory.md) is a real review the skill
  168. produced for the deliberately messy module in the eval cases.
  169. ## Porting code to Rust
  170. Ask your agent to port a module, for example "port parser.c to Rust" or "rewrite this
  171. Python service in Rust". The `rust-port` skill reads the original and its tests, ports the
  172. tests first, designs a Rust API instead of transliterating the original, and verifies with
  173. `cargo test` and `clippy`. It maps each language's habits to their Rust equivalents:
  174. `NULL` and `None` to `Option`, error codes and exceptions to an error enum, out-parameters
  175. to return values, flag ints and magic strings to typed enums and options, and dict
  176. insertion order to an ordered collection instead of a `HashMap` that would silently
  177. reorder output. Each port comes with a `PORTING.md` that maps the old API and tests to the
  178. new ones and lists every deliberate difference.
  179. ## Bevy
  180. Bevy calls your systems and builds their arguments, so some general Rust advice is wrong
  181. for them. Taken at face value, the skills would tell an agent to change `Res<Time>` to a
  182. reference, replace `use bevy::prelude::*` with explicit imports, and split a system to
  183. quiet clippy. When a crate depends on `bevy` or `bevy_ecs`, both the writing and review
  184. skills now read [`references/bevy.md`](skills/rust-best-practices/references/bevy.md)
  185. first. It covers Bevy 0.20 and does two things:
  186. - **It names the conventions to leave alone:** system parameters taken by value, the
  187. Bevy prelude, public fields on plain-data components, and complex query types.
  188. - **It lists the ECS bugs that compile cleanly.** Two queries that can both mutate the
  189. same component panic with error B0001 on the first frame. A system can read the world
  190. before another system's `Commands` have applied. Systems that depend on each other may
  191. have no order between them. A `.single().unwrap()` crashes the game once the player
  192. dies.
  193. Every behavior in the reference was checked with a test against bevy 0.20.0. Two eval
  194. cases cover it: a review of a combat plugin with two of those bugs planted, and a feature
  195. added to the fixed plugin, which checks that the agent keeps Bevy's conventions.
  196. ## Enforcing the rules with clippy
  197. The skills teach the rules; the lints keep them from slipping back in. Copy
  198. [`lints/clippy.toml`](lints/clippy.toml) next to your `Cargo.toml` and paste the `[lints]`
  199. block from [`lints/lints.toml`](lints/lints.toml) into it, then run:
  200. ```bash
  201. cargo clippy --all-targets --all-features -- -D warnings
  202. ```
  203. It flags `unwrap()` outside tests, `unsafe` blocks without a `// SAFETY:` comment, `#[allow]`
  204. without a reason, any `bool` function parameter, silent lossy `as` casts, missing `# Errors`
  205. and `# Panics` docs, `assert!` without a message, exported enums that aren't
  206. `#[non_exhaustive]`, and leftover `dbg!` and `todo!`. Lints marked `[lib]` in the file are
  207. for libraries, and applications can drop them. Bevy crates need four extra allows,
  208. listed in the [Bevy reference](skills/rust-best-practices/references/bevy.md#keep-bevys-conventions),
  209. because the table otherwise flags every idiomatic system signature.
  210. Every lint in the table is proven to fire. [`lints/check/`](lints/check/src/lib.rs) is a small crate
  211. with one deliberate violation per lint, and this script runs clippy on it from the repo
  212. root:
  213. ```bash
  214. bash scripts/check-lints.sh
  215. ```
  216. It fails if a lint stops firing, if something unexpected fires, or if the check crate's
  217. copy of the table drifts from `lints/lints.toml`. `allow_attributes` and
  218. `allow_attributes_without_reason` need `rust-version = "1.81"` or later, because clippy
  219. switches them off for crates that can't use `#[expect]`.
  220. ## What the writing skill covers
  221. `skills/rust-best-practices/SKILL.md` is about 500 lines, organized so an agent can scan
  222. it while coding:
  223. 1. Mindset: Rust-shaped code, invalid states unrepresentable, application vs library
  224. 2. Pre-handback checklist: fmt, clippy with `-D warnings`, test, doc; lint policy
  225. 3. Ownership and borrowing: what to do instead of cloning for the borrow checker
  226. 4. Types and API design: naming, newtypes, common traits, builders, visibility, generics vs `dyn`
  227. 5. Errors and panics: `Option` vs `Result` vs panic, library vs application error types
  228. 6. Everyday idioms: iterators, combinators, `format!`, imports, drop guards
  229. 7. Concurrency and async: `Send` assertions, lock discipline, `async fn`, yield points
  230. 8. Unsafe and FFI: when it's allowed, `SAFETY:` comments, soundness, bindgen
  231. 9. Crates, modules, dependencies: workspace layout, features, semver
  232. 10. Documentation and comments
  233. 11. Tests
  234. 12. Performance, in order
  235. 13. Final checklist
  236. `skills/rust-best-practices/references/` holds one digest per source for deeper lookups.
  237. ## Layout
  238. ```
  239. BeautifulRust/
  240. ├── .claude-plugin/
  241. │ ├── plugin.json Claude Code plugin manifest
  242. │ └── marketplace.json lets this repo act as its own marketplace
  243. ├── .agents/plugins/
  244. │ └── marketplace.json the same, for Codex
  245. ├── plugin.json Codex and ChatGPT plugin manifest
  246. ├── assets/icon.png plugin icon for Codex and ChatGPT
  247. ├── skills/
  248. │ ├── rust-best-practices/ writing skill
  249. │ │ ├── SKILL.md
  250. │ │ ├── references/ one digest per source, plus bevy.md
  251. │ │ └── evals/
  252. │ ├── rust-review/ review skill
  253. │ │ ├── SKILL.md
  254. │ │ └── evals/
  255. │ └── rust-port/ porting skill
  256. │ ├── SKILL.md
  257. │ └── evals/ a C module and a Python module to port
  258. ├── lints/
  259. │ ├── lints.toml [lints] block for Cargo.toml
  260. │ ├── clippy.toml clippy thresholds
  261. │ └── check/ one deliberate violation per lint
  262. ├── scripts/
  263. │ ├── check-skill.py validates skills, evals, and manifests
  264. │ ├── check-lints.sh proves every lint in the table fires
  265. │ ├── check-examples.py compiles every Rust example in the docs
  266. │ ├── examples.json context that lets fragment examples compile
  267. │ ├── package-openai-plugin.py builds the ChatGPT / Codex directory ZIP
  268. │ └── build-mcp-data.py builds the MCP server's search index and lint catalog
  269. ├── mcp/ MCP server (Vercel Function) at mcp.beautifulrust.dev
  270. ├── benchmarks/
  271. │ └── cross-agent-2026-10/ Claude Code vs Codex, with and without the skills
  272. ├── examples/
  273. │ └── review-inventory.md a real review report
  274. ├── CHANGELOG.md
  275. ├── CONTRIBUTING.md
  276. ├── PRIVACY.md
  277. └── README.md
  278. ```
  279. ## Testing the skills
  280. `skills/rust-best-practices/evals/` holds four test cases in the layout `claude plugin eval`
  281. reads: a library API design task, an application CLI task, and a refactor-this-module task
  282. with an input file. Each case has the prompt, a description of a good result, and one
  283. assertion per file under `graders/`. Run them with and without the skill from the skill
  284. directory:
  285. ```bash
  286. claude plugin eval . --allow-tools Write,Edit,Bash --scaffold
  287. ```
  288. `skills/rust-review/evals/` holds a review case for the same messy module and one for a
  289. Bevy plugin with two ECS bugs planted, and `skills/rust-port/evals/` holds a C module and
  290. a Python module to port, each with its original test suite. The writing skill also has a
  291. Bevy case that adds a feature to a working plugin. Run them the same way from each
  292. skill's directory.
  293. These are real model runs and are billed.
  294. **Across agents.** The [October 2026 benchmark](benchmarks/cross-agent-2026-10/README.md)
  295. ran all eight cases on Claude Code and OpenAI's Codex CLI, with and without the skills,
  296. and graded the results blind:
  297. | | No skills | Skills |
  298. | --- | --- | --- |
  299. | Claude Code (Opus 5.5) | 72/85 (85%) | 80/85 (94%) |
  300. | Codex CLI (default model) | 53/85 (62%) | 76/85 (89%) |
  301. The skills helped Codex more than Claude, and helped reviews most. They hurt in one case:
  302. Claude did worse on the Bevy feature task with them. The benchmark page has the details,
  303. the method, and the caveats. Notably, it was one run per configuration, graded by a
  304. Claude model.
  305. ## Updating
  306. Edit the skill, bump `version` in both `.claude-plugin/plugin.json` and `plugin.json`
  307. (the checker fails if they differ), commit, and push. Claude Code plugin users pick up the
  308. new version with:
  309. ```bash
  310. claude plugin update beautiful-rust
  311. ```
  312. Codex users refresh the marketplace with:
  313. ```bash
  314. codex plugin marketplace upgrade beautiful-rust
  315. ```
  316. Anyone who copied the folder or used an installer re-runs the install command. Record
  317. each release in [CHANGELOG.md](CHANGELOG.md).
  318. Validate before pushing. `python3 scripts/check-skill.py` checks skill
  319. frontmatter, links, eval cases, and plugin manifests. Pass `--json` for
  320. machine-readable output. `python3 scripts/check-examples.py` compiles every Rust
  321. block in the skills, reference digests, README, and examples with `cargo check`.
  322. ```bash
  323. python3 scripts/check-skill.py
  324. python3 scripts/check-examples.py
  325. claude plugin validate .
  326. ```
  327. To publish a release to the ChatGPT / Codex Plugins Directory, update `release_notes` in
  328. `plugin.json`, then build the upload:
  329. ```bash
  330. python3 scripts/package-openai-plugin.py
  331. ```
  332. This writes `dist/beautiful-rust-<version>.zip` with the manifest, the skills and their
  333. references, the icon, the license, and the privacy policy, but not the eval cases. Upload
  334. it at [platform.openai.com/plugins](https://platform.openai.com/plugins) from a verified
  335. developer account, as described in OpenAI's
  336. [submission guide](https://developers.openai.com/plugins/deploy/submission).
  337. ## Contributing
  338. Issues and pull requests are welcome. Every rule needs a published source; see
  339. [CONTRIBUTING.md](CONTRIBUTING.md) for how to propose a rule, report a review false
  340. positive, or add an eval case.
  341. ## Sources and attribution
  342. The guidance in this skill is a synthesis. The five digests in
  343. `skills/rust-best-practices/references/` are paraphrased summaries written for this
  344. project; they restate each source's advice in condensed form and link back to the
  345. original. Read the originals for the full reasoning.
  346. | Source | Author | License |
  347. |---|---|---|
  348. | [Google Rust Style Guide](https://google.github.io/styleguide/rustguide.html) | Google | CC BY 3.0 |
  349. | [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/) | The Rust Project | MIT or Apache-2.0 |
  350. | [Effective Rust](https://www.lurklurk.org/effective-rust/) | David Drysdale, published by O'Reilly | CC BY-NC-ND 4.0 (online edition) |
  351. | [Rust Design Patterns](https://rust-unofficial.github.io/patterns/) | rust-unofficial contributors | MPL-2.0 |
  352. | [Pragmatic Rust Guidelines](https://microsoft.github.io/rust-guidelines/) | Microsoft | MIT |
  353. The skill text, the digests, the banner, and the generator script in this repository
  354. are MIT licensed (see [LICENSE](LICENSE)). The crab is a crab, not the Rust mascot.
  355. ## License
  356. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.