What makes rust-dev notable?

2.2K downloads. Trust evidence available

How should rust-dev be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

rust-dev

Day-1 guide to building well in Rust - ownership, errors as values, String vs &str, Box/Rc/Arc, anyhow vs thiserror, and a crate shortlist (tokio, serde, axum, sqlx). Use when starting a Rust project, fighting the borrow checker, or picking crates.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

2.2k

Updated

Oct 9, 2026

Version

0.8.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 2.2K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 2.2K downloadsadoption · observed Oct 9, 2026
Latest release: 0.8.0release · observed Oct 6, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17bp3v1hm1dnkzey0c9tfh02183j0y5:rust-dev

Install using `clawhub skill install s17bp3v1hm1dnkzey0c9tfh02183j0y5:rust-dev` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/tenequm/rust-dev before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-tenequm-rust-dev/snapshot"

Documentation

CLAWHUB

149,394 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: rust-dev
description: Day-1 guide to building well in Rust - ownership, errors as values, String vs &str, Box/Rc/Arc, anyhow vs thiserror, and a crate shortlist (tokio, serde, axum, sqlx). Use when starting a Rust project, fighting the borrow checker, or picking crates.
metadata:
  version: "0.8.0"
  categories: "development"
  topics: "rust, ownership, cargo, crates, tokio"
  upstream: "[email protected], [email protected], [email protected], [email protected], [email protected], [email protected], [email protected], [email protected], [email protected]"
  openclaw:
    homepage: https://github.com/tenequm/skills/tree/main/skills/rust-dev
    emoji: "🦀"
---

# Rust Development - Day 1

A practical foundation for writing Rust apps well from the first commit. Not a textbook. Focuses on the differences from other languages, the day-1 decisions that shape everything else, and the small set of crates that cover most real apps.

## When to Use

- Starting a new Rust project (CLI, service, library)
- Coming to Rust from Python, JavaScript, Go, Java/C#, or C++
- Choosing between owned/borrowed types, smart pointers, trait objects vs generics
- Picking error handling strategy (`anyhow` vs `thiserror`)
- Deciding which crates to reach for
- Configuring a minimal but opinionated `Cargo.toml`, clippy, and rustfmt

## Day-1 Setup

```bash
# 1. Install the toolchain (rustup is the toolchain manager)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 2. Confirm components (rustfmt and clippy ship with stable, rust-src enables IDE features)
rustup component add rustfmt clippy rust-src

# 3. Create a project
cargo new my-app          # binary (src/main.rs)
cargo new --lib my-lib    # library (src/lib.rs)

# 4. The dev loop (memorize these four)
cargo check     # fast type-check, no codegen
cargo run       # build and run (binary)
cargo test      # build and run tests (incl. doctests)
cargo clippy --all-targets   # lint, incl. tests/ and benches/ (run before pushing)
cargo fmt       # format

# 5. Manage dependencies without editing Cargo.toml by hand
cargo add tokio --features full
cargo remove tokio
cargo update                 # recompute Cargo.lock within existing semver ranges
```

`cargo update` only moves within the version ranges already in `Cargo.toml`. Crossing a major version (`1.x` to `2.0`) needs a `Cargo.toml` edit or `cargo add <crate>@2`.

**rust-analyzer is mandatory.** It is the language server every editor uses (VS Code, Zed, Neovim, Helix, RustRover uses its own engine but is comparable). In VS Code, install the `rust-analyzer` extension and set `rust-analyzer.check.command` to `"clippy"` so you get lint feedback on save.

**Want a file watcher later?** `cargo install --locked bacon`, then run `bacon` in your project. Not needed on day 1.

## The Rust Mental Model in 5 Ideas

Rust trades two things you take for granted in most languages (a garbage collector and exceptions) for compile-time guarantees about memory, data races, and error handling. The shap

_meta.json

{
  "ownerId": "kn76gpsgjw5chv0xvzbzcb8cxn81x46r",
  "slug": "rust-dev",
  "version": "0.8.0",
  "publishedAt": 1791291740326
}

references/async-basics.md

# Async Basics

Rust's async is cooperative: `.await` is an explicit yield point. There is no built-in runtime; you pick one. In 2026, that runtime is `tokio` for almost every application. (If a tutorial hands you `async-std`, stop: it has been discontinued, carries a RustSec advisory for that reason, and its own site still shows no notice. `smol` is the named replacement.) This file covers what you need to write async Rust well from day 1, and the small set of pitfalls that cause most async bugs.

## Threads First, Async Second

Before any of this: **async is for I/O concurrency, not for speed.** If your work is CPU-bound - parsing, hashing, image processing, simulation - you want threads, and the standard library already gives you everything you need. Reaching for `tokio` because you want to "use all the cores" is the wrong tool.

```rust
use std::thread;
use std::sync::mpsc;

// Detached-ish: a handle you join to get the result back
let h = thread::spawn(|| expensive(1));   // must be 'static - move owned data in
let a = h.join().unwrap();                // Result: Err means the thread panicked

// Scoped threads: borrow from the stack, guaranteed joined at the end of the scope
let data = vec![1, 2, 3];
thread::scope(|s| {
    s.spawn(|| println!("{:?}", &data));   // &data borrow is fine here
    s.spawn(|| println!("{}", data.len()));
});                                        // both joined before this line returns

// Message passing: the idiomatic way to get results out
let (tx, rx) = mpsc::channel();
for id in 0..4 {
    let tx = tx.clone();
    thread::spawn(move || tx.send(work(id)).unwrap());
}
drop(tx);                                  // the last sender must drop or rx never ends
for result in rx { }                       // iterates until every sender is gone
```

`thread::scope` is the one worth remembering: it is what lets a thread borrow local data instead of forcing you to `Arc`-wrap everything, because the scope cannot exit until every thread inside it has finished. That `drop(tx)` is the classic hang - a receiver loop ends when all senders are dropped, and the original `tx` you cloned from is a sender.

For data parallelism over a collection, do not hand-roll any of this: `rayon`'s `.par_iter()` is one word and covers most of it (see `performance.md`).

## Mental Model

An `async fn` does not run when called. It returns a `Future`, which is a state machine. A runtime (`tokio`) drives futures by polling them; when a poll hits a point that needs to wait (network I/O, timer, channel receive), the future returns "not ready" and the runtime parks it until the underlying event fires.

```rust
async fn add(a: i32, b: i32) -> i32 { a + b }

let f = add(2, 3);   // f is a Future, nothing has run yet
let n = f.await;     // runtime drives f to completion; n == 5
```

`.await` only works inside `async fn` or `async {}` blocks.

## The Minimum You Need

```rust
// Cargo.toml
// [dependencies]
// tokio = { version = "1", features = ["full

references/crate-shortlist.md

# Crate Shortlist

The handful of crates that show up in almost every Rust application. One minimal example each. None are required; pull in as you need them.

For a curated wider catalog, see [blessed.rs](https://blessed.rs/crates).

## `serde` and `serde_json`

Serialization. Derive macros do everything.

```toml
serde = { version = "1", features = ["derive"] }
serde_json = "1"
```

```rust
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct User {
    id: u64,
    email: String,
}

let json = r#"{"id": 1, "email": "[email protected]"}"#;
let user: User = serde_json::from_str(json)?;

let back = serde_json::to_string_pretty(&user)?;
```

Other formats: `toml`, `serde_qs`, `rmp-serde` (MessagePack). Same derive, different crate.

Two names you will find in older guides that you should not reach for now:

- **`serde_yaml` is unmaintained.** Its repository is archived and the last release is `0.9.34+deprecated` (March 2024), with no official successor named. `serde_yaml_ng` and `serde_yml` are community continuations; evaluate them rather than assuming.
- **`bincode` 3.0.0 is a tombstone.** Development stopped after a doxxing and harassment incident, and the entire contents of 3.0.0's `src/lib.rs` is `compile_error!("https://xkcd.com/2347/")` - so adding `bincode = "3"` does not fail at runtime, it fails to compile. `2.0.1` is the last usable release. For a new binary format, upstream points at `postcard` or `rkyv`.

Common attributes:
```rust
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]   // userId on the wire, user_id in Rust
struct Payload {
    user_id: u64,

    #[serde(default)]                // missing field uses Default::default()
    tags: Vec<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    note: Option<String>,
}
```

**Unknown fields are silently dropped by default.** serde's docs: "When this attribute is not present, by default unknown fields are ignored for self-describing formats like JSON." So a misspelled request parameter or a config key renamed in the last release deserializes cleanly and simply does nothing. For config files and API inputs you own, add `#[serde(deny_unknown_fields)]` to the struct so the old key is a hard error. It "is not supported in combination with flatten, neither on the outer struct nor on the flattened field", so a `#[serde(flatten)]` struct needs another way to catch strays.

## `tokio`

Async runtime. The default. See `async-basics.md` for the deep dive.

```toml
tokio = { version = "1", features = ["full"] }
```

```rust
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let sleep = tokio::time::sleep(std::time::Duration::from_millis(100));
    sleep.await;
    Ok(())
}
```

## `anyhow`

App error handling. Use this in binaries.

```toml
anyhow = "1"
```

```rust
use anyhow::{Context, Result, bail};

fn run() -> Result<()> {
    let cfg = std::fs::read("config.toml").context("reading config.toml")?;
    if cfg.is_empty() {

references/dev-environment.md

# Development Environment

Setting up a fast edit-compile-test loop, and keeping it fast as the project grows. None of this is needed on day 1 - reach for it when builds start to feel slow.

## The fast inner loop

The commands, fastest to slowest:

- `cargo check` - type-checks without code generation. This is your inner loop; run it constantly.
- `cargo clippy` - `check` plus lints. Set your editor to run this on save.
- `cargo build` / `cargo run` - full code generation.
- `cargo test` - build plus run tests.

In your editor, point rust-analyzer's check command at clippy so you get lint feedback inline (in VS Code: `"rust-analyzer.check.command": "clippy"`). rust-analyzer itself does most type-checking as you type; `cargo check` is the fallback the editor runs to populate diagnostics.

## Build speed

Two things make Rust builds slow: compiling code, and linking it. Caching compilation is the bigger win and is the same on every platform; the linker story is the part that differs.

### Build caching: use kache

[kache](https://github.com/kunobi-ninja/kache) is a content-addressed `RUSTC_WRAPPER`. It gives you a persistent, global cache of compiled **dependencies** - shared across every project on the machine, surviving `cargo clean`, branch switches, and fresh worktrees or clones at a different path. Cache hits restore zero-copy where the filesystem allows it: a copy-on-write clone on APFS/btrfs/XFS-with-reflink, then a restricted hardlink fallback for immutable artifacts on Unix, and a plain copy for everything else. Since 0.23.0 build-script runs and `cargo clippy` units are cached too, with diagnostics replayed. An optional S3 remote shares artifacts across machines and CI.

```sh
# Install (mise, or brew on macOS)
mise use -g github:kunobi-ninja/kache@latest
brew install kunobi-ninja/kunobi/kache

kache init --check # preview the plan without changing anything
kache init # wires RUSTC_WRAPPER into ~/.cargo/config.toml, installs + starts the daemon
kache doctor # verify
```

`kache init` is idempotent - re-run it any time to repair the setup. It does more than set the wrapper: on Unix it also sets `HOST_CC`/`HOST_CXX` when unset (so the C and C++ that build scripts compile are cached too), offers compiler shims plus a `PATH` line for your shell's startup file, and offers a login service. `-y` accepts the plan non-interactively; `--no-shell` keeps it out of your dotfiles and `--no-service` skips the daemon service. To wire it by hand instead, set `rustc-wrapper = "kache"` under `[build]` in `$CARGO_HOME/config.toml`.

Sharing artifacts across machines needs a remote, in `~/.config/kache/config.toml`:

```toml
[cache.remote]
type = "s3"
bucket = "my-build-cache"
endpoint = "https://s3.example.com" # omit for AWS S3; required for Ceph/MinIO/R2
profile = "my-aws-profile" # an AWS profile, not env vars - see the quirks below
```

The remote `type` can also be `gcs`, `filesystem`, or (since 1.0.0) `oci`, which stor

Github ReposUpdated 5h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.