How to use the Rust Coding Patterns agent skill (rust-patterns)

What an agent skill is and what this one does

An agent skill is a folder containing a SKILL.md file with instructions that an AI agent loads when a task matches the skill's description. This one is named rust-patterns and comes from the ECC source, as listed on this page.

When the skill is active, the agent follows Rust conventions across six areas: ownership and borrowing, Result and ? error propagation, enums and exhaustive pattern matching, traits and generics, concurrency, and minimal pub surfaces organized by domain. It contains only guidance and examples.

• Favors borrowing over cloning when a function does not need ownership.
• Uses Result and ? instead of unwrap() for errors.
• Applies thiserror for library errors and anyhow for application errors.
• Models states as enums and matches them exhaustively.
• Organizes shared state with Arc<Mutex<T>>, channels and async/await.

Install the rust-patterns skill

Download the ZIP for this skill from our page and unzip it. The package contains a single file, SKILL.md.

For a personal install, unzip the folder into ~/.claude/skills/. To scope it to one project, place it in that project's .claude/skills/ folder instead.

In the Claude apps, you can instead upload the ZIP under Settings → Capabilities → Skills.

• Personal: ~/.claude/skills/
• Single project: .claude/skills/ inside the project
• Claude apps: Settings → Capabilities → Skills

Trigger the skill with natural requests

You do not need a special command. The skill is meant to be used when you are writing new Rust code, reviewing Rust code, refactoring existing Rust code, or designing crate structure and module layout. Ask for one of those tasks in plain language and mention Rust clearly.

Naming the pattern you care about, such as error handling or concurrency, helps the agent focus on the relevant section.

• "Review this Rust module for unwrap() calls and suggest Result-based error handling."
• "Refactor this function to borrow instead of cloning."
• "Model these connection states as a Rust enum with exhaustive matching."
• "Suggest a module layout for this Rust crate with a minimal pub surface."
• "Set up shared state across threads using Arc<Mutex<T>>."

Examples of the guidance in practice

The skill's examples show the difference between a preferred and a discouraged style. For error handling, the preferred version uses anyhow's Context to add a message to a failed file read and then uses ?, while the discouraged version calls unwrap() and panics.

For data modeling, it shows an enum for connection states, where each variant carries its own data, so impossible combinations cannot be written. For iterators, it prefers a filter and map chain over a manual loop that pushes into a Vec.

What the skill needs and how it behaves

The skill lists no requirements. It does not run scripts and does not use the network. Its only file is SKILL.md, so there is nothing to execute during use.

Because it is text guidance, its effect depends on the agent reading it and the code you give it. Check the agent's suggestions against your compiler and tests.

• Requires: nothing listed
• Runs scripts: no
• Uses network: no

Know where the rules may not fit

Some rules are opinions rather than laws. For example, "never unwrap()" and "no catch-all match" may not suit every codebase. A wildcard arm can be reasonable in some code, and unwrap() can be acceptable in tests or where an invariant is proven.

Treat the skill as a consistent style baseline for reviews and refactors, and adjust it to your project's own conventions.

• Do not apply rules blindly across a whole codebase in one pass.
• Discuss exceptions with your team and document them.

Tips for getting better results

Give the agent the specific file or function you want reviewed, so it can apply the relevant section instead of general advice.

Ask for a reason with each suggestion so you can judge whether it fits your code.

• Paste the code or point the agent at the file.
• Name the area: errors, ownership, concurrency, or module layout.
• Ask the agent to explain each change before you accept it.