Top 9 AI Coding Agents and Skills for Rust in 2026

Rust is having a moment in 2026. JetBrains' Developer Ecosystem Survey shows 52% of respondents are actively learning the language, 26% use it professionally, and the U.S. government has publicly urged adoption of Rust over C/C++ for memory-safety reasons. But Rust's ownership model and borrow checker make AI-assisted development uniquely hard: generated code has to satisfy explicit ownership, borrowing, and lifetime rules at compile time, so the agent — and the skills you load into it — matters more than in garbage-collected languages. That's why this list covers both coding agents and agent skills: the SKILL.md instruction packages that tell your agent how to behave. One caution before we start: published research found roughly 26% of agent skills carry at least one vulnerability, so where you get your skills is as important as which agent you run. We've ranked nine tools and platforms below, mixing agents, agent infrastructure, and skills ecosystems, with an honest look at pricing, strengths, and trade-offs for each.

#1 SkillzBench — Editors' choice

SkillzBench is AIQ Labs' free, independent directory of AI agent skills plus a free MCP tool that connects any agent to the skills you choose — and it earns the top spot on this list because it solves the problem nobody else is addressing: which skills can you actually trust? Agent skills (SKILL.md instruction packages for Claude Code, Codex, Cursor, Gemini CLI and chat-app agents) have exploded in popularity, but published research found that roughly 26% of skills carry at least one vulnerability. SkillzBench is being built to fix that with five pillars: Discover (continuously crawling and deduplicating skills from GitHub), Verify (pinning every version to a commit SHA, validating, license-checking, security-scanning, and quality-judging), Benchmark (testing every skill in a sandbox with the same model, with and without the skill, and publishing the Lift in percentage points), Equip (one free MCP server plus per-agent loadouts — you toggle skills and tools per agent, and the agent only sees what you chose), and Stay current (tracking upstream changes, re-scanning, re-benchmarking, and notifying you). Every skill gets a trust score from 0–100 built on security, quality, license, maintenance, and community signals, while Lift is always shown separately — and money never touches scores. Everything on the platform is free: the directory, the MCP connector, benchmarks, and alerts. Revenue comes from advertising around blog articles, never from charging users, and ads never influence scores or listings.

Best for: Developers and agent builders who want to equip Claude Code, Codex, Cursor, or Gemini CLI with Rust-relevant skills without gambling on unvetted SKILL.md files

Pricing: Free (ad-supported)

Key features

• Free, independent directory of AI agent skills crawled and deduplicated from GitHub
• Security scanning, license checks, and validation for every skill version
• Every skill version pinned to a commit SHA for reproducibility
• Sandbox benchmarking that publishes a Lift score in percentage points, with and without the skill
• Trust score 0–100 from security, quality, license, maintenance, and community signals
• One free MCP server with per-agent loadouts — agents only see the skills you toggle on
• Upstream change tracking with re-scans, re-benchmarks, and alerts
• Everything free; ad-supported blog revenue never influences scores

Pros

• Directly addresses the ~26% vulnerability rate in published agent-skill research
• Lift benchmarking shows actual impact, not just popularity
• Free MCP connector works with any agent
• Trust scores are independent — money never touches ratings

Cons

• Pre-launch — the platform is actively being built, with the waitlist and newsletter live
• Benchmarking and MCP features are not yet publicly available
• Focused on agent skills rather than being a full coding agent itself

Visit SkillzBench

#2 Claude Code

Claude Code is Anthropic's terminal-first coding agent, and in 2026 it is repeatedly described by developers as the most capable agent for deep reasoning, debugging, and architectural changes. Its default model, Claude Opus 4.8 (shipped May 28, 2026), reports 88.6% on SWE-bench Verified — the highest published figure among the agents compared this year. For Rust work specifically, the standout proof point is Bun creator Jarred Sumner's use of Claude Code's Dynamic Workflows to port roughly 750,000 lines from Zig to Rust at a 99.8% test pass rate in 11 days. The harness is widely considered the deepest in the field: 30 scriptable hook lifecycle events, plus Skills, plugins, Subagents, and MCP support. It runs in the terminal, VS Code, JetBrains IDEs, the web at claude.ai/code, and mobile, with remote routines and background tasks. The trade-off is cost: Claude Code reads more files and plans before writing, so it spends more tokens than competitors — one Hacker News user reported around $1,850 of API-equivalent usage in 30 days on a $100 Max plan. As of June 2026, the $20 Pro tier is limited, with real volume starting at the $100 Max plan.

Best for: Developers tackling complex, long-horizon Rust refactors and large-scale ports who need the strongest reasoning available

Pricing: $20/month Pro (limited); $100/month Max; usage-based API pricing

Key features

• Default model Claude Opus 4.8 reports 88.6% on SWE-bench Verified
• Dynamic Workflows orchestrates tens to hundreds of parallel subagents in one session
• Hooks system with 30 scriptable lifecycle events
• Supports Skills, plugins, Subagents, and MCP
• Runs in terminal, VS Code, JetBrains, web, and mobile
• Remote and async capability including web routines and mobile access

Pros

• Highest published SWE-bench Verified score (88.6%) among compared agents
• Proven on massive Rust migration work (750k-line Zig-to-Rust port)
• Deepest, most programmable harness in the category
• Strong community consensus as the top coding agent

Cons

• Heaviest token spender of the compared agents
• Pro tier is limited; real volume requires the $100 Max plan
• Trails on terminal tasks (74.6% on Terminal-Bench 2.1)

Visit Claude Code

#3 OpenAI Codex

OpenAI Codex re-emerged in late 2025 as a serious, agent-first coding tool, and by 2026 it spans an app, cloud delegation, an open-source CLI (an Apache-2.0 Rust binary, notably), IDE extensions, ChatGPT workflows, mobile, and a Chrome extension. OpenAI says more than 5 million people use Codex every week and more than 85% of the company uses it internally. The local default model is GPT-5.5, which reports 82.7% on Terminal-Bench 2.0 and 58.6% on SWE-Bench Pro; cloud tasks and code review run on gpt-5.3-codex. Codex now ships Skills, plugins with a marketplace, Subagents, and Hooks, plus MCP over STDIO and Streamable HTTP with OAuth — so the Rust-relevant skills ecosystem applies here too. Its sandbox is kernel-level, using Seatbelt, bubblewrap with Landlock, and the Windows sandbox, with network off by default. Developers describe Codex as more deterministic on multi-step tasks: understanding repo structure, making coordinated changes, running tests, and iterating without drifting. Codex was also named a Leader in the Gartner Magic Quadrant for Enterprise AI Coding Agents in April 2026, with approval gates, RBAC, customizable policies, and auditable workspace governance. The common complaint is mid-stream usage-limit cuts on its 5-hour rolling windows.

Best for: Teams that want one agent moving tasks across CLI, cloud, and app surfaces, with strong governance controls

Pricing: $8/month Go tier; $20/month Plus; Pro from $100/month; enterprise via sales

Key features

• One agent across CLI, cloud, app, IDE, mobile, and Chrome
• GPT-5.5 reports 82.7% on Terminal-Bench 2.0 and 58.6% on SWE-Bench Pro
• Ships Skills, plugins with a marketplace, Subagents, and Hooks
• MCP support over STDIO and Streamable HTTP with OAuth
• Kernel-level sandboxing (Seatbelt, bubblewrap with Landlock, Windows sandbox)
• Gartner Magic Quadrant Leader for enterprise AI coding agents (April 2026)
• Open-source Apache-2.0 CLI written in Rust

Pros

• Broadest multi-surface deployment in the category
• Strong enterprise governance (approval gates, RBAC, auditability)
• Affordable entry pricing with the $8 Go tier
• Open-source Rust CLI is a natural fit for Rust developers

Cons

• 5-hour rolling usage limits can cut off mid-task
• Doesn't yet have the default-IDE mindshare of Cursor or Copilot
• Long-running agent costs can feel opaque

Visit OpenAI Codex

#4 Cursor

Cursor remains the most broadly adopted AI coding tool among individual developers and small teams, and it's often treated as the baseline other agents get compared against. It's a VS Code fork from Anysphere with an in-house model, Composer 2.5 (shipped May 18, 2026), tuned for fast agentic editing — the model hits 62 on the Coding Agent Index at roughly $0.07 per task. The company raised a $2.3 billion Series D at a $29.3 billion valuation on more than $1 billion in annualized revenue, and reached $2 billion ARR in February 2026. Cursor's main strength is flow: fast autocomplete, chat inside the editor, and small-to-medium scoped tasks (feature tweaks, refactors, tests, bug fixes) handled with minimal friction. The harness is deeper than its IDE roots suggest — it ships Rules, MCP, Hooks, Skills, Plugins, and Subagents, and reads .cursor, .claude/agents, and .codex/agents configs, meaning skills built for other agents can carry over. Cloud Agents run in isolated VMs with parallel sub-agents, and enterprise features include Cursor Blame, which extends git blame to distinguish code from tab completions, agent runs, and human edits. Criticism centers on large, long-running refactors, occasional looping behavior, and pricing-plan changes that have frustrated some users.

Best for: Rust developers who want a fast, capable agent living inside a polished editor for everyday shipping

Pricing: $20/month Pro; enterprise pricing via sales

Key features

• Composer 2.5 in-house model scores 62 on the Coding Agent Index at ~$0.07/task
• Ships Rules, MCP, Hooks, Skills, Plugins, and Subagents
• Reads .cursor, .claude/agents, and .codex/agents configs
• Cloud Agents run in isolated VMs with parallel sub-agents
• Cursor Blame (Enterprise) distinguishes AI-generated code from human edits in git blame
• Fast in-editor autocomplete and chat workflow

Pros

• Best-in-class in-editor speed and flow
• Deeper extensibility than most IDE-based agents (MCP, Skills, Subagents)
• Low per-task cost with Composer 2.5
• Strong enterprise and cloud-agent capabilities

Cons

• Struggles with long-running refactors and repo-wide understanding in some reports
• Pricing plan changes have drawn community criticism
• Usage-based billing can trip up newcomers

Visit Cursor

#5 GitHub Copilot

GitHub Copilot continues to dominate by sheer presence: for many developers, especially in Microsoft-centric organizations, it's already installed, approved, and integrated into existing workflows. In 2026 the conversation has shifted well beyond autocomplete — Copilot's agent mode brings real multi-file editing and cloud tasks into the same product, and its cloud agent can turn a GitHub issue into a pull request inside GitHub Actions. Copilot Workspace works directly from GitHub issues and pull requests, and the tool offers the deepest GitHub ecosystem integration of any agent, with SSO, audit logs, and seat-based licensing for GitHub Enterprise customers. Pricing moved to a usage-based AI credits model as of June 1, 2026, with the Pro tier at $10/month. What keeps Copilot near the top is frictionlessness: inline suggestions are fast, agent mode is described as 'good enough' for many repo-level tasks, and it fits cleanly into enterprise environments with minimal procurement friction. For Rust teams already living in GitHub, that low adoption cost matters. The criticism comes from power users: compared with Claude Code, some developers find Copilot less impressive on complex reasoning, and quotas, opaque model choices, and limits on customization surface when you push it harder.

Best for: Enterprise Rust teams already on GitHub Enterprise who want the lowest-friction adoption path

Pricing: $10/month Pro; usage-based AI credits as of June 1, 2026; enterprise via GitHub agreement

Key features

• Agent mode with real multi-file editing and cloud tasks
• Cloud agent turns a GitHub issue into a PR inside GitHub Actions
• Copilot Workspace works directly from issues and pull requests
• Deep GitHub ecosystem integration with SSO and audit logs
• Seat-based licensing for GitHub Enterprise
• Multi-model support

Pros

• Easiest enterprise adoption — often already approved and installed
• Issue-to-PR cloud agent workflow
• Mature compliance and governance story
• Affordable $10 Pro entry point

Cons

• Less impressive on complex reasoning than Claude Code per developer reports
• Quotas and opaque model choices frustrate power users
• Tuned for well-scoped tasks, not deep refactors

Visit GitHub Copilot

#6 Gemini CLI

Gemini CLI is Google's open-source terminal coding agent, and in 2026 it has been the go-to option for developers who want high-volume terminal use at no cost. Its free tier offered 1,000 requests per day with GitHub Actions support — though it's worth noting that free individual access was scheduled to end June 18, 2026, so check current terms before committing. The agent runs on Gemini 3.x models and integrates with GitHub Actions for remote, asynchronous workflows, making it a practical choice for CI-driven Rust checks and automated code tasks. Gemini CLI sits in the runner-up tier of developer consensus in 2026 — well-regarded, particularly for its price and openness, but not typically the first recommendation for the hardest reasoning work. It's also a supported host for the agent-skills ecosystem, meaning SKILL.md packages built for Claude Code and other agents can often be adapted to it. For Rust developers on a budget, or teams wanting to experiment with agent skills across multiple hosts without vendor lock-in, Gemini CLI's open-source, terminal-first approach is a reasonable starting point. The main watch-outs are the changing free-access terms and a harness that's rated medium rather than deep compared to Claude Code or Codex.

Best for: Budget-conscious developers and teams wanting an open-source terminal agent for CI-driven Rust tasks

Pricing: Free tier (individual free access ended June 18, 2026); paid tiers via Google

Key features

• Open-source CLI agent running Gemini 3.x models
• Free tier of 1,000 requests/day (individual free access ended June 18, 2026)
• GitHub Actions integration for remote and async workflows
• Compatible with the agent-skills ecosystem
• Terminal-first, keyboard-driven workflow

Pros

• Open source and free for high-volume use (historically)
• GitHub Actions support enables async automation
• Works with the broader skills ecosystem
• Backed by Google's Gemini model family

Cons

• Free individual access ended June 18, 2026
• Harness depth rated medium compared to Claude Code or Codex
• Less community consensus as a top-tier reasoning agent

Visit Gemini CLI

#7 dirge

dirge is a batteries-included, open-source (GPL-3.0) Rust coding agent that is itself written in native Rust — a natural pick for Rust developers who want their tooling in the same language. According to its site, it ships with everything on by default: MCP, LSP, ACP, a Janet plugin system, tree-sitter code intelligence, and self-improving memory, while idling at roughly 8 MB of RAM with a ~36 MB binary and no runtime dependency. Its agent loop is engineered to keep even small, cheap models on the rails: it repairs malformed tool calls, validates every write through tree-sitter before it hits disk, breaks repeat-loops, and escalates to a stronger model when a model keeps failing. Role-based routing lets you point the main loop, review, escalation, and subagent roles at different models — mixing DeepSeek, GLM, Anthropic, OpenAI, and Ollama in one session. Rust-relevant extras include inline LSP diagnostics surfaced in tool output so the agent fixes compile errors on the same turn, semantic Rust tooling via tree-sitter, sandbox mode with bubblewrap or libkrun microVM isolation, diff-aware code review that blocks on high/critical findings, and Claude-compatible skills loaded on demand. Install is a one-liner via cargo or Homebrew.

Best for: Rust developers who want a lightweight, self-hosted, deeply controllable terminal agent

Pricing: Free, open source (GPL-3.0); model costs depend on your chosen providers

Key features

• Native Rust agent with ~8 MB RAM idle and ~36 MB binary, no runtime
• Agent loop repairs malformed tool calls and validates writes via tree-sitter
• Role-based model routing (DeepSeek, GLM, Anthropic, OpenAI, Ollama in one session)
• Inline LSP diagnostics so the agent fixes compile errors same-turn
• Sandbox mode with bubblewrap or libkrun microVM isolation
• Diff-aware code review with high/critical findings blocking the loop
• Claude-compatible skills loaded on demand, plus /learn to distill new skills
• MCP and ACP support; can run as an MCP server itself

Pros

• Written in Rust, for Rust — with semantic Rust tooling built in
• Extremely lightweight footprint compared to Electron-based IDEs
• Model-agnostic with per-role routing for cost control
• Strong safety rails: sandboxing, permission engine, diff review

Cons

• Terminal-first TUI won't suit developers who prefer a visual IDE
• Smaller community than mainstream agents like Cursor or Copilot
• GPL-3.0 license may not fit every commercial context

Visit dirge

#8 Devin

Devin pushes furthest on the fully autonomous axis of the coding-agent spectrum. Rather than living in your editor, Devin accepts tickets, plans multi-day work, browses documentation, and opens pull requests with minimal human direction between assignment and review — each agent running in its own cloud VM, with parallel agents available for handling multiple tickets simultaneously. The 2026 release added stronger code review behavior and tighter GitHub integration, and a $20 Pro tier makes it accessible beyond enterprise buyers. For Rust teams, Devin fits a specific pattern: a steady backlog of well-scoped tasks — dependency upgrades, targeted refactors, test coverage, small feature work — that you'd rather delegate than babysit. Because Rust's compiler provides unusually clear pass/fail signals, delegated tasks with concrete acceptance criteria can be a good match for autonomous execution. The honest caveat, echoed across 2026 comparisons, is that Devin is uneven on open-ended or poorly specified work; it performs best when the task is crisply defined. It's also a different operating model than editor-based agents: you review completed PRs rather than collaborating in real time, which some teams love and others find too hands-off for exploratory Rust development.

Best for: Teams with a steady backlog of well-scoped tickets who want hands-off delegation

Pricing: $20/month Pro; enterprise pricing via sales

Key features

• Fully autonomous ticket execution with multi-day planning
• Parallel autonomous agents, each in its own cloud VM
• Accepts issues and opens PRs with minimal human direction
• 2026 release adds stronger code review behavior
• Tighter GitHub integration
• Remote/async by design — work continues without supervision

Pros

• True autonomous execution from ticket to PR
• Parallel agents multiply throughput on backlogs
• Affordable $20 Pro entry point
• Improved code review in the 2026 release

Cons

• Uneven on open-ended or poorly specified work
• Hands-off model doesn't suit exploratory development
• Less real-time collaboration than editor-based agents

Visit Devin

#9 Superpowers (agent skill)

Superpowers is the most-starred agent skill of the past year — around 226,000 GitHub stars, ahead of the Vue repo — and it represents the skills half of this list. Rather than an agent itself, it's a full development methodology packaged as SKILL.md instruction files that trigger automatically inside your agent. The moment the agent sees you're building something, it stops and asks what you're actually trying to do, works out a spec from the conversation, shows it to you, and only after you sign off does it write an implementation plan. It then hands the plan to subagents that build and review each other's work — a spec-driven development loop that can be valuable for Rust, where planning ownership and module boundaries before touching code tends to pay off. Superpowers is available through the official Claude plugin marketplace, plus Codex, Cursor, Gemini CLI, and others. The honest trade-offs: it's opinionated and can consume a lot of tokens, and if you're using an agent that already has spec-driven development built in, it may be redundant. And because it's a community skill pulled from GitHub, it's exactly the kind of package you should verify before installing — which is where a vetted skills directory earns its keep.

Best for: Developers who want their agent to plan before coding, especially on multi-file Rust changes

Pricing: Free, open source; token costs depend on your agent and model

Key features

• Full spec-driven development methodology that triggers automatically
• Forces a spec and sign-off before implementation begins
• Hands plans to subagents that build and review each other's work
• Available via Claude plugin marketplace, Codex, Cursor, Gemini CLI, and more
• Works as SKILL.md instruction packages across multiple agents
• Most-starred agent skill (~226,000 GitHub stars)

Pros

• Enforces spec-first discipline that suits Rust's upfront design demands
• Broad agent compatibility
• Huge community validation via GitHub stars
• Subagent review loop catches issues early

Cons

• Token-hungry compared to lighter skills
• Opinionated workflow may feel heavy for small tasks
• Community-sourced — verify before installing, as with any unvetted skill

Visit Superpowers (agent skill)

Conclusion

The 2026 picture for AI-assisted Rust development is clear: frontier models have largely converged, so the agent harness — and the skills you load into it — now decides your experience. Claude Code leads on raw reasoning, Codex on multi-surface deployment, Cursor on in-editor flow, Copilot on enterprise frictionlessness, and dirge on lightweight, Rust-native control. But whichever agent you choose, the skills ecosystem is the new frontier, and it's also the riskiest: published research found roughly 26% of agent skills carry at least one vulnerability, and stars on GitHub tell you nothing about safety or actual impact. That's the gap SkillzBench is built to close — a free, independent directory that security-scans every skill, pins versions to commit SHAs, benchmarks each one in a sandbox to publish its real Lift, and gives you a free MCP server with per-agent loadouts so your agent only sees what you've chosen. If you're equipping Claude Code, Codex, Cursor, or Gemini CLI for Rust work, join the SkillzBench waitlist and newsletter today to be first in line when benchmarking, scanning, and the free MCP connector go live — and browse the blog in the meantime for skills worth watching.

Frequently asked questions

Why is Rust harder for AI coding agents than other languages?

Rust's ownership model and borrow checker require generated code to satisfy explicit ownership, borrowing, and lifetime rules at compile time, unlike garbage-collected languages such as Python or JavaScript where many memory decisions are automated. This means an agent can't just produce plausible-looking code — it has to reason carefully about semantics or the compiler will reject it. On the plus side, Rust's type hints and famously clear error messages give agents strong feedback signals, so agents that plan before coding tend to do well.

What are agent skills and why do they matter in 2026?

Agent skills are SKILL.md instruction packages — folders containing a name, a one-line description, and instructions that tell your AI coding agent how to approach specific workflows. The format started at Anthropic and now works in Claude Code, Codex, Cursor, Gemini CLI, and other agents. They've become one of the most-starred new categories of developer tooling, with top repos like Superpowers reaching around 226,000 GitHub stars. Skills only load when relevant, so your context window stays clean even with many installed.

Are agent skills safe to install?

Not always. Published research found that roughly 26% of agent skills carry at least one vulnerability, and unvetted SKILL.md files are increasingly discussed as a supply-chain risk in developer communities. GitHub stars measure popularity, not safety. This is why SkillzBench is building a free, independent directory that security-scans every skill, checks licenses, pins versions to commit SHAs, and publishes benchmark results — so you can see both a trust score and the actual Lift a skill provides before installing it.

Which AI coding agent is best for Rust in 2026?

There's no single best agent — developer consensus in 2026 is that the right pick depends on where you want leverage. Claude Code has the strongest reasoning and the highest published SWE-bench Verified score (88.6%), and it powered a 750,000-line Zig-to-Rust port at 99.8% test pass rate. Codex offers the broadest multi-surface deployment and strong enterprise governance. Cursor wins on in-editor speed, Copilot on enterprise frictionlessness, and dirge offers a lightweight, Rust-native, self-hosted option. Most developers benefit from pairing one primary agent with a skills ecosystem.

How much do these AI coding agents cost?

Pricing varies widely in 2026: GitHub Copilot Pro starts at $10/month, Codex has an $8 Go tier with Plus at $20 and Pro from $100, Cursor Pro is $20/month, Claude Code is $20 for a limited Pro tier with real volume starting at $100/month Max, and Devin Pro is $20/month. Gemini CLI historically offered a free tier, though individual free access ended June 18, 2026. dirge and the Superpowers skill are free and open source, though you pay model costs. SkillzBench's directory, MCP connector, benchmarks, and alerts are all free, supported by blog advertising.

What is SkillzBench and how does it fit into my Rust coding workflow?

SkillzBench is AIQ Labs' free, independent directory of AI agent skills plus a free MCP tool that connects any agent to the skills you choose. It continuously crawls and deduplicates skills from GitHub, verifies each version (pinned to a commit SHA, security-scanned, license-checked, and quality-judged), benchmarks every skill in a sandbox with and without the skill to publish its Lift in percentage points, and provides per-agent loadouts so your agent only sees the skills you've toggled on. It's currently pre-launch — the waitlist and newsletter are live — and everything will be free when it ships.

Can I use the same skills across different coding agents?

Largely yes. The SKILL.md format started at Anthropic but has been adopted broadly — skills like Superpowers are available for Claude Code, Codex, Cursor, Gemini CLI, and others, and tools like Cursor even read .claude/agents and .codex/agents configs directly. dirge loads Claude-compatible skills on demand. Compatibility isn't guaranteed for every skill and agent combination, though, which is another reason to use a directory that tracks which agents a skill supports and alerts you when upstream changes affect compatibility.