Best Claude Code Skills for Rust and Go [2026]

Five of the 11 Rust and Go skills we installed earn a place in an agent’s context. @apollographql/rust-best-practices leads at 45/50 — a 2,430-line handbook across 10 files, published in apollographql/skills on GitHub. Scores, sources and file-level detail follow.

The other four come from wshobson/agents, jeffallan/claude-skills, poteto/noodle and sammcj/agentic-coding. All five install through npx skills add and work with Claude Code, Cursor and Windsurf.

Updated September 2026: scores and file-level detail are unchanged. Install counts below are the April 2026 snapshot — each skill page on SkillSafe carries the live number.

Quick Comparison

Skill	Score	Key Feature	Language / Tools	Installs
@apollographql/rust-best-practices	45/50	9-chapter Rust handbook: ownership, errors, testing, generics, type state	Rust 1.70+, Cargo, Clippy	3,127
@wshobson/rust-async-patterns	42/50	7 production async patterns with Tokio, channels, streams, graceful shutdown	Rust, Tokio, async-trait	3,471
@jeffallan/golang-pro	40/50	5-file Go reference: concurrency, interfaces, generics, testing, project layout	Go 1.21+, gRPC, pprof	1,844
@poteto/go-best-practices	39/50	10 production patterns: ordered shutdown, non-blocking fanout, layered config	Go, Cobra, slog, golangci-lint	1,627
@sammcj/rust-engineer	35/50	Broad Rust systems checklist: ownership, async, FFI, WASM, embedded, macros	Rust, Tokio, Miri, Clippy	4,650

Figure: Scores out of 50. The 10-point spread between first and fifth is almost entirely depth and actionability — the bottom entry has the most installs and the fewest code examples.

How We Scored

Each skill was scored out of 50 across five dimensions:

Dimension	Max	What we looked at
Relevance	10	Does it address real systems concerns — memory safety, concurrency, performance?
Depth	10	Specific patterns and idioms vs. vague advice. Line counts, code examples, file counts.
Actionability	10	Can a developer follow the guidance to write better Rust/Go code right now?
Structure	10	Well-organized with navigable files, clear language-specific coverage?
Adoption	10	Install count, stars, update frequency.

Skills that listed topics without code examples scored lower on depth. Skills that restated official documentation — the Rust book’s ownership chapter, Effective Go — without adding agent-oriented framing scored lower on actionability.

This article combines both languages into one roundup for a practical reason: Rust and Go are the two dominant systems languages in 2026, but Go currently has fewer than four quality skills in the registry. Rather than publish a thin Go list alongside a Rust list, we combined them. The two languages share a target audience — developers building concurrent services, CLIs, and performance-sensitive infrastructure — even though they solve memory safety from opposite directions (Rust’s ownership model vs. Go’s garbage collector with escape analysis).

Several candidates were eliminated early. @actionbook/rust-learner (5,399 installs) turned out to be a browser automation engine with no Rust programming content. @subsy/ralph-tui-create-beads-rust (2,306 installs) is a project management tool for converting PRDs to task beads — its “Rust” is in the tool name, not the skill content. @jeffallan/rust-engineer bundles 66 skills for full-stack development and is not Rust-specific. These are the five that actually teach systems programming.

What Separates a Deep Skill From a Thin One

The scoring spread in this roundup comes down to one question: does the file contain code the agent could not have written on its own? Compare the top and bottom entries. Apollo’s chapter 1 spends 552 lines on borrowing alone, with anti-patterns marked explicitly and a primitive-size table so the agent can decide whether a struct qualifies for Copy. @sammcj/rust-engineer names 13 domains — ownership, traits, async, FFI, embedded, WASM — across 295 lines and implements none of them.

Both cost the agent context to load. Only one changes the code that comes out.

Figure: The same rubric applied to the highest and lowest scorer in this roundup. Install count does not predict either side.

1. @apollographql/rust-best-practices — 45/50

Source: apollographql/skills (MIT) · 3,127 installs · Scan: A+

This is the most comprehensive Rust skill in the registry, at 2,430 lines across 10 files. It is based on Apollo GraphQL’s internal Rust best practices handbook, and it reads like a team style guide that has been battle-tested in a production codebase — because it is one.

Archive structure:

SKILL.md                           ← hub with quick reference rules
references/
  chapter_01.md                    ← Coding styles: borrowing, Copy, Option/Result, iterators, comments (552 lines)
  chapter_02.md                    ← Clippy and linting (117 lines)
  chapter_03.md                    ← Performance mindset (209 lines)
  chapter_04.md                    ← Error handling (180 lines)
  chapter_05.md                    ← Automated testing (381 lines)
  chapter_06.md                    ← Generics and dispatch (161 lines)
  chapter_07.md                    ← Type state pattern (226 lines)
  chapter_08.md                    ← Comments vs documentation (254 lines)
  chapter_09.md                    ← Understanding pointers, Send/Sync (256 lines)

The hub SKILL.md is 94 lines of dense quick-reference rules. It tells the agent exactly when to prefer &str over String in function parameters, when Cow<'_, T> is the right choice, and gives a size threshold for Copy types: 24 bytes or less. These are the kind of concrete heuristics that change generated code.

Chapter 1 alone is 552 lines covering borrowing vs. cloning with anti-patterns marked explicitly. It includes a primitive type size table (every integer, float, and bool with byte sizes) so the agent can reason about whether a struct qualifies for Copy. The section on Option<T> and Result<T, E> handling walks through five distinct pattern-matching strategies with clear rules for when to use each — match for inner-type inspection, let Ok(..) else for early returns, if let for divergent computation.

Chapter 5 on testing (381 lines) covers snapshot testing with cargo insta, rstest for parameterized tests, and a firm rule: one assertion per test. It includes the module-based naming convention mod test { mod function_name { fn returns_y_when_x() } } that gives meaningful test output paths.

Where it loses points: The skill has no install count stars despite strong content, suggesting it hasn’t been discoverable. The chapter structure, while thorough, means an agent must load multiple files to get full coverage on a topic that spans chapters (e.g., error handling touches both chapter 1 and chapter 4).

Score breakdown: Relevance 10/10 · Depth 10/10 · Actionability 9/10 · Structure 9/10 · Adoption 7/10

npx skills add https://api.skillsafe.ai/apollographql/rust-best-practices

2. @wshobson/rust-async-patterns — 42/50

Source: wshobson/agents (MIT) · 3,471 installs · 59 stars · Scan: A+

This is a single-file skill — 513 lines — and it covers the topic that trips up AI-generated Rust code more than any other: async programming with Tokio. Where most skills mention “use Tokio” and move on, this one provides seven complete, copy-pasteable patterns with the right imports and error handling.

The skill opens with an execution model diagram showing the Future → poll() → Ready | Pending → Waker → Runtime cycle, then provides a quick-reference table mapping Future, async fn, await, Task, and Runtime to their purposes. That’s agent-friendly framing — it gives the model a mental model before hitting code, and it matches the sequencing the Tokio tutorial itself uses.

The seven patterns cover the exact scenarios that arise in production async Rust:

1. Concurrent task execution — JoinSet for spawning, buffer_unordered() for concurrency limits, select! for racing
2. Channels — mpsc, broadcast, oneshot, and watch with complete examples for each
3. Async error handling — Custom error types with thiserror, anyhow for application code, timeout wrappers
4. Graceful shutdown — Both CancellationToken and broadcast-channel approaches
5. Async traits — Repository pattern with async_trait macro and dyn Trait usage
6. Streams — async_stream::stream!, chunked processing, stream merging
7. Resource management — RwLock, Semaphore-based connection pooling with proper Drop implementation

The resource management pattern (Pattern 7) is the most valuable for an AI agent. It shows a complete connection pool implementation using Semaphore for backpressure, Mutex<Vec<Connection>> for the pool, and a PooledConnection wrapper with a Drop impl that returns connections. This is the kind of pattern that an AI would otherwise generate incorrectly — forgetting the semaphore permit, or blocking on the mutex while holding the permit.

Where it loses points: Single-file means no navigability — the agent loads all 513 lines even when it only needs the channel patterns. A hub-and-reference structure would score higher. The debugging section at the end (tracing, tokio-console) is thin compared to the pattern sections.

Score breakdown: Relevance 10/10 · Depth 9/10 · Actionability 9/10 · Structure 7/10 · Adoption 7/10

npx skills add https://api.skillsafe.ai/wshobson/rust-async-patterns

3. @jeffallan/golang-pro — 40/50

Source: jeffallan/claude-skills (MIT) · 1,844 installs · 37 stars · Scan: F (false positives on Go code examples)

This is the most complete Go skill in the registry, at 2,253 lines across 6 files. It covers five core domains — concurrency, interfaces, generics, testing, and project structure — each in a dedicated reference file with working code examples.

Archive structure:

SKILL.md                           ← hub with workflow, core example, constraints
references/
  concurrency.md                   ← Worker pools, channels, select, sync primitives, rate limiting (329 lines)
  interfaces.md                    ← Single-method interfaces, composition, accept/return pattern (432 lines)
  generics.md                      ← Type parameters, constraints, generic patterns (442 lines)
  testing.md                       ← Table-driven tests, subtests, benchmarks, fuzzing (451 lines)
  project-structure.md             ← Module layout, internal packages, go.mod (477 lines)

The hub SKILL.md defines a six-step workflow (analyze, design interfaces, implement, lint, optimize, test) and includes a complete core example: a worker function with context cancellation, error propagation via %w, and a runPipeline caller that demonstrates bounded goroutine lifetime. That single example demonstrates three Go concurrency best practices in 40 lines.

The concurrency reference (329 lines) is the strongest file. It provides five production patterns — worker pool, generator/fan-out/fan-in, select with timeout, done-channel shutdown, and semaphore-based rate limiting — each with full implementations. The worker pool uses a buffered channel (workers*2 capacity), sync.WaitGroup for lifecycle management, and a clean Shutdown() method. The fan-out/fan-in pattern chains three functions (generateNumbers, fanOut, fanIn) with context.Context threaded through every goroutine.

The constraints section in the SKILL.md sets hard rules: “Use gofmt and golangci-lint on all code”, “Add context.Context to all blocking operations”, “Run race detector on tests (-race flag)”. These are the kinds of enforceable directives that make AI code reviews more consistent.

Where it loses points: The scan grade is F due to 8 false-positive “reverse shell” detections on Go code examples containing net package patterns — the kind of finding the SkillSafe scanner surfaces for a human to adjudicate rather than a verdict to act on blindly. The generics reference, at 442 lines, spends significant space on basic syntax that Go 1.21+ developers already know. The project structure file is the weakest — it’s closer to documentation than instruction.

Score breakdown: Relevance 9/10 · Depth 9/10 · Actionability 8/10 · Structure 8/10 · Adoption 6/10

npx skills add https://api.skillsafe.ai/jeffallan/golang-pro

4. @poteto/go-best-practices — 39/50

Source: poteto/noodle (MIT) · 1,627 installs · Scan: C (1 false positive)

This skill takes a different approach from @jeffallan/golang-pro. Instead of covering Go’s language features, it covers 10 production patterns that experienced Go developers learn the hard way: ordered shutdown, non-blocking fanout, layered config, secure debug logging, golden test matrices, and focused linting.

Archive structure:

SKILL.md                           ← 60-line hub with 10 rules
references/patterns.md             ← 370 lines of code patterns

The hub file reads like a team engineering document. Rule 3 is typical of the register:

Ordered shutdown. Cancel dependents before their dependencies, then run independent cleanup in parallel under a timeout context. WaitGroup the parallel phase.

— poteto/noodle, .agents/skills/go-best-practices/SKILL.md

Rule 4 is equally specific: “Non-blocking channel sends with an explicit drop policy. Log drops at debug level. Document the policy.” These are specific enough to generate correct code and opinionated enough to prevent common mistakes.

The patterns file backs each rule with complete implementations. The non-blocking fanout pattern (Pattern 4) is the standout — it shows both the publisher side (select with default for drop-on-full) and the consumer side (a forward function with Stop → drain → Reset timer sequence to prevent timer leaks). The comment “The Stop, drain, Reset sequence prevents timer leaks and deadlocks” addresses a specific Go timer footgun that causes production bugs.

Pattern 5 on concurrency testing covers Go 1.24’s testing/synctest for deterministic timing, goleak.VerifyNone for goroutine leak detection, and a dedicated deadlock regression test template. synctest fakes the clock inside an isolated goroutine bubble, which is what makes a timing test deterministic rather than merely slow — the Go team’s own introduction to the package is worth reading alongside the skill. Pattern 8 shows a debugTransport wrapping http.RoundTripper that redacts authorization, API key, token, and secret headers — a real security pattern, not a toy example.

Where it loses points: At 430 total lines, the skill is compact compared to the 2,000+ line competitors. It assumes familiarity with Go fundamentals (no coverage of interfaces, generics, or basic concurrency primitives). The .golangci.yml example in Pattern 10 is useful but brief — it lists seven linters without explaining why each catches real bugs beyond one-line comments.

Score breakdown: Relevance 9/10 · Depth 8/10 · Actionability 9/10 · Structure 7/10 · Adoption 6/10

npx skills add https://api.skillsafe.ai/poteto/go-best-practices

5. @sammcj/rust-engineer — 35/50

Source: sammcj/agentic-coding (Apache-2.0) · 4,650 installs · Scan: C (1 false positive)

This is a single-file, 295-line Rust skill that takes the broadest possible scope: ownership, traits, error handling, async, performance, memory management, testing, systems programming, macros, FFI, embedded development, WebAssembly, and concurrency patterns. It is a checklist, not a handbook — and that is both its strength and its limitation.

The skill opens with a development checklist: “Zero unsafe code outside of core abstractions, clippy::pedantic compliance, complete documentation with examples, comprehensive test coverage including doctests, benchmark performance-critical code, MIRI verification for unsafe blocks.” This is immediately useful as a quality gate for AI-generated Rust code.

The ownership and borrowing section lists eight specific techniques: lifetime elision, interior mutability patterns, smart pointer usage (Box, Rc, Arc), Cow for efficient cloning, Pin API for self-referential types, PhantomData for variance control, Drop trait implementation, and borrow checker optimization. The trait system section adds eight more: trait bounds, associated types, generic trait implementations, trait objects, extension traits, marker traits, supertraits, and const trait implementations.

The breadth is remarkable for 295 lines. It covers embedded development (no_std compliance, interrupt handlers, DMA safety), WebAssembly (wasm-bindgen, size optimization, WASI compliance), and FFI (bindgen, cbindgen, ABI stability) — domains that no other Rust skill in the registry touches.

Where it loses points heavily: There are zero code examples. Every section is a bullet-point list of techniques without implementations. The skill tells the agent to “use type state pattern” but doesn’t show one. It mentions “arena allocation patterns” without demonstrating the pattern. Compare this to @apollographql/rust-best-practices, which provides 552 lines of code examples for borrowing alone. For an AI agent, a list of technique names is less actionable than a single working implementation.

Score breakdown: Relevance 9/10 · Depth 5/10 · Actionability 5/10 · Structure 7/10 · Adoption 9/10

npx skills add https://api.skillsafe.ai/sammcj/rust-engineer

Frequently Asked Questions

Why are Rust and Go combined in one article?

Go currently has fewer than four high-quality skills in the SkillSafe registry. Rather than publish a padded Go-only list, we combined the two languages that share the most audience overlap: backend services, CLI tools, and infrastructure software, both with concurrency as a first-class concern. The contrast is useful — Rust skills concentrate on ownership, Go skills on lifecycle and shutdown.

Do I need both a general Rust skill and the async patterns skill?

Yes, if you write async Rust. @apollographql/rust-best-practices covers ownership, error handling, testing, and type-level patterns but has minimal async content. @wshobson/rust-async-patterns covers Tokio-specific patterns in depth but doesn’t address borrowing idioms. Together they are 2,943 lines: install the Apollo skill as your baseline style guide and add the async one for services.

Which Go skill should I install — golang-pro or go-best-practices?

It depends on experience. @jeffallan/golang-pro covers fundamentals (interfaces, generics, project structure) alongside concurrency and testing across 2,253 lines. @poteto/go-best-practices assumes you know Go and jumps to production patterns in 430 lines. New service: start with golang-pro. Debugging goroutine leaks or designing a shutdown sequence: go-best-practices.

Where do these Claude Code skills live on GitHub?

Every skill here is a directory in a public repository: apollographql/skills, wshobson/agents, jeffallan/claude-skills, poteto/noodle and sammcj/agentic-coding. SkillSafe mirrors each one, records the upstream commit, and runs a security scan against it, so the skill page shows both the source path and the scan result before you install.

Do these skills work in Cursor and Windsurf, not just Claude Code?

Yes. All five are plain Markdown SKILL.md files with no tool-specific dependencies, installed with npx skills add https://api.skillsafe.ai/{namespace}/{name}. The installer writes to .claude/skills/ and .cursor/skills/; Windsurf reads the same format. Nothing in these five skills calls a Claude-only API.

Conclusion

The systems programming skill landscape is uneven. Rust has one exceptional skill (@apollographql/rust-best-practices at 2,430 lines) and one focused specialist (@wshobson/rust-async-patterns at 513 lines) that together cover the language thoroughly. Go has two solid skills that divide the territory well: @jeffallan/golang-pro for fundamentals and @poteto/go-best-practices for production patterns. The gap is in Rust skills that include working code — @sammcj/rust-engineer’s 4,650 installs show demand for broad Rust coverage, but its checklist format limits what an AI agent can actually generate from it.

If you install only two skills from this list, make it @apollographql/rust-best-practices and @jeffallan/golang-pro. They have the highest depth-to-noise ratio and together cover the most ground across both languages.

Next in this series: the TypeScript roundup applies the same rubric to 12 type-system and tooling skills, and the Python roundup covers async, Django and FastAPI.

Related roundups: Browse all Best Of roundups · All Claude Code posts