Best AI Skills for Systems Languages: Rust and Go [2026]

We installed 11 Rust and Go skills from the SkillSafe registry, read every file, and scored them on five dimensions. 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.

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 without adding agent-oriented framing scored lower on actionability.

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

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

Source: github.com/apollographql · 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

skillsafe install @apollographql/rust-best-practices

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

Source: github.com/wshobson/agents · 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.

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

skillsafe install @wshobson/rust-async-patterns

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

Source: github.com/jeffallan/claude-skills · 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 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

skillsafe install @jeffallan/golang-pro

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

Source: 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: “Cancel dependents before their dependencies, then run independent cleanup in parallel under a timeout context. WaitGroup the parallel phase.” Rule 4: “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. 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

skillsafe install @poteto/go-best-practices

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

Source: 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

skillsafe install @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. Both are used for backend services, CLI tools, and infrastructure software. Both prioritize concurrency as a first-class concern. The combination also highlights a useful contrast: Rust skills tend to focus on ownership and memory safety patterns, while Go skills emphasize concurrency primitives and production operational patterns. Developers working on systems that span both languages (e.g., a Go API gateway calling Rust-based processing libraries) benefit from having both in one reference.

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 or non-async error handling. The two skills complement each other: install the Apollo skill as your baseline Rust style guide, and add the async patterns skill when you’re building Tokio-based services. Together they cover 2,943 lines of guidance.

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

It depends on your experience level. @jeffallan/golang-pro is the better starting point — it covers fundamentals (interfaces, generics, project structure) alongside concurrency and testing. @poteto/go-best-practices assumes you already know Go and jumps straight to production patterns (ordered shutdown, timer drain safety, golden tests). If you’re building a new Go service from scratch, start with golang-pro. If you’re debugging goroutine leaks or designing a graceful shutdown sequence in an existing codebase, go-best-practices is more immediately useful.

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.

Related roundups: Browse all Best Of roundups