Best AI Agent Skills for Rust Developers in 2026

Quick Answer

The shortlist

Stale crate docs are the actual problem

Ask an agent to wire up an async task with a popular runtime and there's a decent chance you get an API shape from a release well behind the one in your Cargo.toml. The code looks plausible. It cites real type names. It doesn't compile, and the error points somewhere unhelpful because the mistake was two layers up in the call.

rust-docs-mcp-server exists for exactly this. It's an MCP server that fetches documentation for the crates in your Cargo.toml, embeds it, and serves it back as a tool call the agent can make mid-task. The agent stops working from memory and starts working from docs.rs for the version you pinned.

Worth knowing before you install it: our directory lists it as community tier and unreviewed, maintained by Govcraft under MIT, and the last update recorded is November 2025. It's a small project doing one job. Read the source before you point it at a private workspace, which is the standing advice for any community skill and doubly so for one that reads your dependency tree.

The workflow that pays off is unglamorous. Before an agent writes anything against an unfamiliar crate, have it pull the current docs for that crate. You'll notice the difference immediately in how many compile cycles a task takes.

Let the compiler be the test, then test anyway

The most common bad pattern in agent-driven Rust is the flail. The agent gets a borrow-checker error, changes a lifetime annotation, gets a different error, adds a clone(), gets a third error, and twenty minutes later the code compiles and allocates in a hot loop for no reason.

Systematic Debugging is the counter. It forces a hypothesis before an edit: state what you think is wrong, gather evidence, isolate one variable, verify the fix. Applied to a borrow error, that means the agent has to articulate which value is owned where and why the lifetime doesn't reach, before it's allowed to touch the code. Rust errors are unusually well-suited to this because the compiler already tells you the shape of the problem in the note lines that people skim past.

Test-Driven Development matters here for a reason specific to Rust. A clean compile feels like a passing test, and it isn't. It proves memory safety and type correctness, not that your function returns the right answer. Agents lean on the green checkmark from cargo build and stop early. Forcing a failing test first removes that shortcut. Rust's built-in test harness makes it cheap, since #[cfg(test)] modules live in the same file and there's no framework to choose.

Both ship inside Superpowers, obra's MIT-licensed pack of about 20 development skills covering debugging, code understanding, performance work, security auditing, and accessibility. Installing the parent pack and using two of its skills is fine, and it's what most people end up doing.

How to install these

Three mechanisms exist, and mixing them up is the usual reason an install appears to do nothing.

Plugin marketplace, for skill packs distributed as plugins. Add the marketplace, then install from it, both from inside Claude Code: /plugin marketplace add obra/superpowers followed by /plugin install superpowers. The skills then load automatically when their trigger conditions match.

Personal skill, for anything you write or vendor yourself. Create ~/.claude/skills/skill-name/SKILL.md with frontmatter describing when the skill applies. No install step, it's picked up from disk.

MCP server, which is what rust-docs-mcp-server is, despite living in a skills directory. Register it with claude mcp add, passing the command from the project's own README, then confirm it's connected with /mcp. MCP servers add tools; skills add instructions. rust-docs-mcp-server needs to be a server because it fetches and embeds documents at runtime.

Check the repository README for the exact command rather than trusting any one-line install string, including ours. Project entry points move.

What's missing, and I'd rather say so

There is no equivalent of a first-class Rust skill pack right now. Nothing in the directory bundles clippy-lint interpretation, unsafe block auditing, macro expansion reading, or crate-feature-flag reasoning into a single installable skill. Agent skills grew out of web and Python work, and Rust is underserved.

Fullstack Dev Skills is the closest general-purpose option, 66 skills from jeffallan covering APIs, databases, DevOps, and testing under MIT. Very little of it is Rust-specific. Compound Engineering from EveryInc brings incremental development and documentation-driven design conventions that transfer across languages, which helps with the crate-splitting decisions that come up in larger workspaces.

If you're writing an MCP server in Rust to expose an internal service, MCP Builder is Anthropic's own official skill for the job. It generates TypeScript by default, so treat it as a reference for correct protocol shape, schemas, error handling, and auth, then implement the equivalent in Rust.

The gap is an opportunity if you maintain Rust tooling. A skill that reads cargo clippy --message-format=json and explains the lint in the context of the surrounding code would be immediately useful and doesn't exist.

A setup that works

Point the agent at current crate docs before it writes against any dependency you haven't touched this month. Make it run cargo check after every edit rather than at the end of a batch, because the feedback loop is the entire advantage of the language. Require a failing test before implementation on anything with real logic. When an error repeats twice, stop and force a written hypothesis instead of a third attempt.

And keep unsafe out of agent scope entirely. Not because a model can't write it, but because reviewing generated unsafe correctly takes longer than writing it yourself, which erases the point.

For adjacent stacks, we cover the same ground for Go developers and for backend frameworks. Developers comparing editors rather than skills should start with our full list for developers.

FAQ

Is there a dedicated Rust agent skill pack?

No. As of August 2026 the directory has no Rust-specific skill bundle covering clippy, macros, and unsafe auditing. rust-docs-mcp-server is the only Rust-targeted entry, and it solves documentation freshness rather than teaching the language.

Do I need an agent skill if Rust already has a strict compiler?

The compiler catches wrong code. It doesn't catch code that compiles and does the wrong thing, and it doesn't stop an agent from thrashing through fifteen edits to clear one lifetime error. Skills address the process, not the correctness the compiler already guarantees.

Is rust-docs-mcp-server safe to install?

It's listed as community tier and unreviewed, MIT licensed, maintained by Govcraft. That means nobody has audited it for you. It reads your dependency list and fetches documentation, which is low-risk in shape, but read the source before running it against a private repository.

Should I use TDD with Rust when the type system is this strong?

Yes, and for a different reason than in dynamic languages. Types constrain the shape of your data. Tests constrain behaviour. In agent-driven work the second one matters more, because a green compile is the shortcut an agent will take if you let it.

Skills or MCP servers for Rust work?

Both, for different jobs. Skills inject instructions and process. MCP servers add tools that fetch live data, which is why documentation lookup has to be a server. Our explainer on agent skills, subagents, and hooks covers where each fits.