Skip to main content
skill CX Codex

rust-coder — Claude Code skill for Rust: setup and features

The rust-coder Claude Code skill implements and refactors Rust code using the project’s own conventions. It activates for feature work, migrations, and substantial edits to .rs files or Cargo.toml.

Apache-2.0 ★ 869 updated 2026-11-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sno-ai/sno-station-skills --skill rust-coder -a claude-code
Open on GitHub

What rust-coder does

rust-coder examines repository guidance, Cargo files, target modules, nearby callers, and tests before editing. It reads references/standards.md first, then shapes the change around the project’s API, ownership model, error handling, and platform boundaries.

The skill aims for a small, coherent patch that reuses existing types and crates. It avoids adding unsafe or extra dependencies just to satisfy the compiler. After editing, it reviews the diff and runs the repository’s own checks; when no stronger local commands apply, it uses cargo fmt --all --check, cargo check, cargo test, and Clippy. File read/write tools and shell access are required. After three unsuccessful fix rounds, it stops and reports the blocker rather than widening the change.

What it helps with

  • implement a feature in a Rust crate
  • refactor types and error handling
  • migrate Rust code while preserving its API contract
  • run Cargo and Clippy checks on a code change

Example prompts for the agent

  • Add handling for this new state to the crate and test it.
  • Refactor this Rust module while keeping its public API intact.
  • Move this function to the new types and run the project checks.

How to install rust-coder

1Skills CLI (Vercel)

npx skills add sno-ai/sno-station-skills --skill rust-coder -a claude-code

2Manually: put the files in place

~/.claude/skills/rust-coder/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/rust-coder/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about rust-coder

How do I install rust-coder in Claude Code?

Run npx skills add sno-ai/sno-station-skills --skill rust-coder -a claude-code. The skill file is placed at ~/.claude/skills/rust-coder/SKILL.md.

What does rust-coder do?

It inspects a Rust repository, makes code changes, and runs checks used by the project. Its tasks include features, libraries, CLIs, services, async code, FFI, and migrations.

What tools does rust-coder need?

It requires file-reading and editing tools plus shell access to run project commands. Cargo and Clippy are used when they are part of the repository’s checks.

Source text

SKILL.md · Apache-2.0
---
name: rust-coder
description: "Implement, refactor, and migrate production Rust with repository-grounded ownership, type-driven invariants, explicit errors, safe concurrency, minimal unsafe code, and verified Cargo workflows. Use for Rust features, crates, CLIs, services, libraries, async code, FFI, performance work, migrations, or substantial .rs and Cargo.toml changes, including requests such as 'rust-coder', 'write Rust', or 'implement this Rust feature with Codex'."
requires:
  programs: []
  harness:
    - {slot: 4.shell, need: required}
    - {slot: 4.file-read-write, need: required}
---

# Rust Coder

Implement directly in the current Codex session. Do not launch another Codex process.

Read [references/standards.md](references/standards.md) completely before editing. Repository instructions and the declared toolchain override generic preferences.

## Inspect

Read the smallest complete set of evidence:

- Nearest `AGENTS.md`, `CLAUDE.md`, and repository instructions.
- Root and target `Cargo.toml`, `Cargo.lock`, `rust-toolchain*`, Cargo configuration, lint and format configuration, features, targets, and continuous-integration commands.
- Every target file in full, its parent exports, immediate callers, traits, types, errors, feature gates, platform boundaries, focused tests, and one or two tested sibling modules.
- The exact format, check, test, Clippy, feature, and target commands used by the crate.

Determine the edit mode, crate kind, toolchain and minimum Rust version, public contract, ownership, resource lifecycle, error model, concurrency and cancellation, safety boundary, and invariants. Default to a hard cut; preserve compatibility only when an explicitly confirmed published contract requires it.

Ask only when an unresolved fact could change public behavior, durable state, safety, or migration semantics. Otherwise make repository-grounded assumptions and continue.

## Design and implement

Resolve the change in this order:

1. Domain invariants and invalid states.
2. Ownership, borrowing boundaries, and resource lifetimes.
3. Types, state transitions, public API, and errors.
4. Concurrency, cancellation, and platform boundaries when relevant.
5. Implementation mechanics and measured optimization.

Work directly with the available read and edit tools. Make the smallest coherent change and preserve unrelated work. Reuse existing crates, types, traits, errors, runtime, and helpers. Do not add dependencies, features, configuration, compatibility paths, `unsafe`, smart pointers, clones, lint suppressions, or abstractions merely to satisfy the compiler.

Treat borrow-checker and trait errors as design feedback. Keep checking and revising until the observable success criteria pass.

## Verify

1. Review the diff; every changed line must trace to the request.
2. Run the repository's exact commands. Without stronger local commands, use focused equivalents of `cargo fmt --all --check`, `cargo check`, `cargo test`, and `cargo clippy --all-targets --all-features -- -D warnings`.
3. Exercise every changed public feature combination and target that local tooling can validate.
4. Search changed production Rust for unexplained `clone`, `Arc`, `Rc`, `Box`, interior mutability, `unwrap`, `expect`, panics, placeholders, `unsafe`, and lint suppressions.
5. Add documentation, compile-fail, property, concurrency, Miri, package, or consumer checks only when the changed contract makes them relevant.

If a check fails, fix the exact observed failure and rerun it. Stop after three failed correction rounds and report the blocker instead of widening scope, cloning around ownership, adding unsafe code, or weakening validation.

## Report

Lead with the outcome. Name changed files, consequential assumptions, ownership/type/error decisions, compatibility decisions, and every command actually run with its result.

© sno-ai · Apache-2.0 · sno-ai/sno-station-skills

Similar skills

All skills for Programming languages →

From the same set40

The whole set →
agentic-time-estimate agentic-time-estimate — a Claude Code skill that estimates an AI agent’s total runtime or remaining work from measured progress. It gets owner-facing clock times from sno report-time and never estimates human developer time. CX Codex +1 ★ 869repo stars ts-coder The ts-coder Claude Code skill guides TypeScript and TSX implementation and refactoring within an existing repository. It applies to work on types, APIs, and migrations. CX Codex +1 ★ 869repo stars test-writer test-writer — a skill for Claude Code writes and improves test code. It activates when Codex is asked to add or change tests. CX Codex +1 ★ 869repo stars shellscript-coder shellscript-coder — a Claude Code skill for writing and refactoring shell scripts and command-line tools. It applies to automation, Git helpers, and infrastructure tasks. CX Codex +1 ★ 869repo stars python-coder The python-coder skill for Claude Code guides Python implementation and refactoring, including work with FastAPI and Pydantic. It applies to async code and migration tasks. CX Codex +1 ★ 869repo stars owner-intent-audit The owner-intent-audit Claude Code skill checks plans, tests, and code against the project owner’s intent. Run it before approving or merging agent work. CX Codex +1 ★ 869repo stars less-is-more less-is-more — a skill for Claude Code that keeps code changes small and trims overbuilt solutions. It activates for coding, bug fixes, refactors, and diff reviews. CX Codex +1 ★ 869repo stars first-principles-review The first-principles-review Claude Code skill challenges product ideas, PRDs, and architecture using first-principles reasoning. It runs only when explicitly named and writes a local review with a PRD handoff. CX Codex +1 ★ 869repo stars

Project sponsors

Companies that keep this analytics open