Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

rust-dev

/rust-dev

Stosuje rygorystyczne standardy Rust, w tym obsługę błędów typu fail fast, architekturę workspace i zarządzanie zależnościami.

Repozytorium
cc ↗
Licencja
MIT
Ostatnia zmiana repozytorium
25.08.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
13
Skrypty
3
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.08.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 3 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: assets/workspace-template/project-cli/src/main.rs, assets/workspace-template/project/src/lib.rs, scripts/check_crate_version.py

Co robi i kiedy

Stosuje rygorystyczne standardy Rust, w tym obsługę błędów typu fail fast, architekturę workspace i zarządzanie zależnościami.

Oryginalny opis (EN)

This skill should be used when working with Rust code, reviewing Rust code, managing Rust dependencies, creating Rust projects, or fixing Rust compilation errors. It provides strict coding standards (especially FAIL FAST error handling), workspace architecture guidance, dependency management automation, and common Rust patterns.

Jak działa

  1. Runtime dispatch
  2. Workflow
  3. Core Rules
  4. Adding Dependencies
  5. Creating New Projects
  6. Module Organization
  7. Error Handling
  8. References
  9. Scripts
Sekcje z nagłówków SKILL.md, w oryginale · 83 linii, 567 słów
Podgląd SKILL.md
---
name: rust-dev
description: This skill should be used when working with Rust code, reviewing Rust code, managing Rust dependencies, creating Rust projects, or fixing Rust compilation errors. It provides strict coding standards (especially FAIL FAST error handling), workspace architecture guidance, dependency management automation, and common Rust patterns.
allowed-tools: Read, Bash(python3 *), Bash(cargo *)
---

# Rust Development

## Runtime dispatch

Detect the runtime once, before the workflow:

- Claude Code (`Agent`, `AskUserQuestion`, and `Skill` tools available) → read `runtime-claude.md`.
- OMP (`task` and `ask` tools available, with `skill://…` readable through `read`) → read `skill://rust-dev/runtime-omp.md`.
- Any other tool surface → stop and report that this skill has no dispatch table for the runtime.

The selected file is a prompt asset, not a role declaration. Its implementation and review labels name the exact runtime subagent arguments. If a named agent is unavailable, stop before delegation: never substitute the generic `task` or `general-purpose` agent and never implement delegated work inline.

## Workflow

For any non-trivial Rust change:

1. **Discover project guidelines** — Read `CLAUDE.md`, `AGENTS.md` (in repo root and `.claude/`, `.cursor/`, `.codex/` subdirs), `rustfmt.toml`, `clippy.toml`, `.clippy.toml`, `deny.toml`, and `[workspace.lints]` / `[lints]` sections in `Cargo.toml`. These rules apply in addition to Core Rules below.

2. **Implement** — Delegate through the runtime dispatch table's implementation entry. It rediscovers guidelines, implements, then verifies its own work with `cargo clippy --workspace --tests -- -D warnings` and `cargo test --workspace` before reporting done.

3. **Review** — Delegate through the dispatch table's review entry after implementation completes. This is mandatory, not optional. Convert findings into TODOs: critical/warning → fix; suggestions → triage.

4. **Fix issues one by one** — Delegate each fix through the implementation entry. Do not batch unrelated fixes into one delegation.

5. **Final build** — Run `cargo build --workspace` directly.

## Core Rules

1. **Edition 2024**: Always `edition = "2024"` in Cargo.toml
2. **FAIL FAST**: Every error MUST propagate with `?` or `return Err`. Logging is NOT handling. See [error-handling.md](references/error-handling.md)
3. **Dependency versions**: Use `x.x` format (e.g., `serde = "1.0"`). Find latest with `python3 scripts/check_crate_version.py <crate>`
4. **Workspace architecture**: Root Cargo.toml defines workspace only. Separate crates for lib/cli/client
5. **Error types**: `thiserror` (with backtrace) for libraries, `anyhow` for binaries/tests
6. **CLI-first config**: Never bypass CLI args. Use `from_cli_args()`, never `Default` that reads env
7. **No `env::set_var` in tests**: Pass config through function parameters
8. **Async**: Use tokio consistently
9. **Visibility**: Private (default) > `pub(crate)` > `pub`
10. **No magic numbers**: Use `const` or CLI args

## Adding Dependencies

1. Run `python3 scripts/check_crate_version.py <crate-name>` to find latest version
2. Add to `[workspace.dependencies]` in root Cargo.toml with `x.x` format
3. Reference in member crates: `serde = { workspace = true }`

Common deps: `thiserror = "2.0"`, `anyhow = "1.0"`, `tokio = { version = "1", features = ["full"] }`, `serde = { version = "1.0", features = ["derive"] }`, `clap = { version = "4.5", features = ["derive"] }`

## Creating New Projects

Use the template in `assets/workspace-template/`:

```
project/
├── Cargo.toml              # Workspace root, no code
├── project/                # Library crate (thiserror)
│   ├── Cargo.toml
│   └── src/lib.rs
└── project-cli/            # Binary crate (anyhow + clap)
    ├── Cargo.toml
    └── src/main.rs
```

## Module Organization

Split modules when file exceeds ~500 lines or tests take 50%+ of file. See [module-organization.md](references/module-organization.md) for patterns.

## Error Handling

The most critical standard. See [error-handling.md](references/error-handling.md) for full rules and examples.

**Quick check:** If you see `if let Err` or `match ... Err` without `return Err` or `?`, it's a bug.

## References

- [error-handling.md](references/error-handling.md) — FAIL FAST rules, thiserror/anyhow patterns, error chain preservation
- [module-organization.md](references/module-organization.md) — When/how to split modules, test extraction
- [dependency-guide.md](references/dependency-guide.md) — Workspace deps, feature flags, common crates

## Scripts

- `scripts/check_crate_version.py` — Query crates.io for latest dependency versions
Pliki w paczce (13)
  • SKILL.md 5 KB
  • runtime-claude.md 1 KB
  • runtime-omp.md 1 KB
  • assets/workspace-template/Cargo.toml 1 KB
  • assets/workspace-template/README.md 1 KB
  • assets/workspace-template/project/Cargo.toml 1 KB
  • assets/workspace-template/project/src/lib.rs 1 KB
  • assets/workspace-template/project-cli/Cargo.toml 1 KB
  • assets/workspace-template/project-cli/src/main.rs 2 KB
  • references/dependency-guide.md 2 KB
  • references/error-handling.md 2 KB
  • references/module-organization.md 1 KB
  • scripts/check_crate_version.py 4 KB

Wersje

W bazie nie ma innych skilli o nazwie rust-dev.

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 1c53b1f52b77 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100rust
    Podpowiada dobre praktyki Rust przy pisaniu i przeglądzie kodu: struktura, wzorce, wydajność i obsługa błędów.
  • 100rust
    Wskazuje, jak pisać i przeglądać kod Rust zgodnie z wytycznymi stylu, gdy użytkownik o to prosi.
  • 100rust-programming
    Pomaga pisać, przeglądać i refaktoryzować kod Rust: crate'y w workspace, publiczne API, obsługę błędów, async i ownership.
  • 95rust-error-handling
    Opisuje obsługę błędów w Rust z Result, Option, własnymi typami błędów, thiserror i anyhow.
  • 90rust-architecture
    Porządkuje backend w Rust: układ workspace, moduły, obsługę błędów, runtime async i projekt sterowany typami, z flagami funkcji.
  • 100rust-best-practices
    Stosuje wytyczne Microsoft Pragmatic Rust przy każdej edycji kodu Rust: obsługa błędów, projekt API, wydajność i idiomy.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.