PluginBench
Skill
Pass
Audit score 90

rust-router

actionbook/rust-skills

Router skill for all Rust questions—directs to specialized language, design, and domain skills.

What is rust-router?

This is a meta-routing skill for Rust coding agents. It classifies incoming Rust questions by cognitive layer (language mechanics, design choices, or domain constraints) and directs users to the appropriate specialized skill (m01–m15 or domain-specific modules). Use it as the entry point for any Rust-related query, especially errors, comparisons, or domain-specific problems.

  • Routes Rust questions to specialized skills based on error codes, keywords, and cognitive layer
  • Identifies whether a question targets language mechanics (Layer 1), design patterns (Layer 2), or domain constraints (Layer 3)
  • Triggers negotiation protocol for comparative queries ("vs", "best practice", "compare")
  • Loads dual skills when domain keywords co-occur with technical errors
  • Provides error-code lookup table (E0382, E0597, E0277, etc.) to direct to correct skill
  • Suggests default Cargo.toml and project settings for new Rust projects

How to install rust-router

npx skills add https://github.com/actionbook/rust-skills --skill rust-router
Claude Code
Cursor
Windsurf
Cline

How to use rust-router

  1. 1.Install the skill via: npx skills add https://github.com/actionbook/rust-skills --skill rust-router
  2. 2.When you encounter a Rust question, check if it contains error codes (E0xxx), domain keywords, or comparison triggers
  3. 3.Use the error-code routing table to find the appropriate Layer 1 skill (m01–m07)
  4. 4.For design questions, consult the Layer 2 routing table (m09–m15)
  5. 5.For domain-specific work, load the corresponding domain skill (domain-web, domain-fintech, etc.)
  6. 6.If the query requires comparison or involves multiple layers, enable the negotiation protocol

Use cases

Good for
  • User asks "How do I fix E0382?" → Router directs to m01-ownership skill
  • User asks "tokio vs async-std" → Router enables negotiation protocol and synthesizes comparison
  • User asks "How do I build a payment system in Rust?" → Router loads both m01-ownership and domain-fintech skills
  • User asks "Why does my borrow checker error happen?" → Router traces cognitive layers and suggests m01 or m03 depending on error type
  • User asks "Best practice for error handling in web APIs?" → Router enables negotiation and cross-references m06-error-handling and domain-web
Who it's for
  • Rust developers encountering compiler errors or design questions
  • Teams building domain-specific applications (fintech, web, CLI, embedded, ML)
  • Coding agents (Claude Code, Cursor) needing to route Rust queries to specialized knowledge
  • Developers comparing Rust async runtimes, patterns, or architectural approaches

rust-router FAQ

What should I do if a question involves both a compile error and a domain (e.g., "E0382 in my payment system")?

Load BOTH skills: the error-specific skill (m01-ownership for E0382) and the domain skill (domain-fintech). The router will identify this as a dual-skill scenario and trace through both layers.

When should I enable the negotiation protocol?

Enable negotiation when the query contains comparison keywords ("vs", "compare", "versus"), asks for best practices, or involves ambiguous scope across multiple layers. The protocol ensures you disclose confidence levels and gaps.

What if a question doesn't match any error code or domain keyword?

Check the Functional Routing Table for patterns like "latest version" (→ rust-learner), "API docs" (→ docs-researcher), or "code style" (→ coding-guidelines). If still unclear, trace the cognitive layer the user is asking about.

How do I handle keyword conflicts (e.g., a question mentioning both 'unsafe' and 'FFI')?

Use the Priority Hierarchy: error codes first, then negotiation triggers, then domain keywords, then crate-specific skills, then general concepts. For 'unsafe', always prefer unsafe-checker over m11-ecosystem.

What Cargo.toml settings should I recommend for new projects?

Always suggest edition = "2024", rust-version = "1.85", and enable lints: unsafe_code = "warn" and clippy all/pedantic = "warn".

Full instructions (SKILL.md)

Source of truth, from actionbook/rust-skills.


name: rust-router description: |- CRITICAL: Use for ALL Rust questions including errors, design, and coding. HIGHEST PRIORITY for: 比较, 对比, compare, vs, versus, 区别, difference, 最佳实践, best practice, tokio vs, async-std vs, 比较 tokio, 比较 async, Triggers on: Rust, cargo, rustc, crate, Cargo.toml, 意图分析, 问题分析, 语义分析, analyze intent, question analysis, compile error, borrow error, lifetime error, ownership error, type error, trait error, value moved, cannot borrow, does not live long enough, mismatched types, not satisfied, E0382, E0597, E0277, E0308, E0499, E0502, E0596, async, await, Send, Sync, tokio, concurrency, error handling, 编译错误, compile error, 所有权, ownership, 借用, borrow, 生命周期, lifetime, 类型错误, type error, 异步, async, 并发, concurrency, 错误处理, error handling, 问题, problem, question, 怎么用, how to use, 如何, how to, 为什么, why, 什么是, what is, 帮我写, help me write, 实现, implement, 解释, explain globs: ["/Cargo.toml", "/*.rs"]


Rust Question Router

Version: 2.0.0 | Last Updated: 2025-01-22

v2.0: Context optimized - detailed examples moved to sub-files

Meta-Cognition Framework

Core Principle

Don't answer directly. Trace through the cognitive layers first.

Layer 3: Domain Constraints (WHY)
├── Business rules, regulatory requirements
├── domain-fintech, domain-web, domain-cli, etc.
└── "Why is it designed this way?"

Layer 2: Design Choices (WHAT)
├── Architecture patterns, DDD concepts
├── m09-m15 skills
└── "What pattern should I use?"

Layer 1: Language Mechanics (HOW)
├── Ownership, borrowing, lifetimes, traits
├── m01-m07 skills
└── "How do I implement this in Rust?"

Routing by Entry Point

User SignalEntry LayerDirectionFirst Skill
E0xxx errorLayer 1Trace UP ↑m01-m07
Compile errorLayer 1Trace UP ↑Error table below
"How to design..."Layer 2Check L3, then DOWN ↓m09-domain
"Building [domain] app"Layer 3Trace DOWN ↓domain-*
"Best practice..."Layer 2Both directionsm09-m15
Performance issueLayer 1 → 2UP then DOWNm10-performance

CRITICAL: Dual-Skill Loading

When domain keywords are present, you MUST load BOTH skills:

Domain KeywordsL1 SkillL3 Skill
Web API, HTTP, axum, handlerm07-concurrencydomain-web
交易, 支付, trading, paymentm01-ownershipdomain-fintech
CLI, terminal, clapm07-concurrencydomain-cli
kubernetes, grpc, microservicem07-concurrencydomain-cloud-native
embedded, no_std, MCUm02-resourcedomain-embedded

INSTRUCTIONS FOR CLAUDE

CRITICAL: Negotiation Protocol Trigger

BEFORE answering, check if negotiation is required:

Query ContainsAction
"比较", "对比", "compare", "vs", "versus"MUST use negotiation
"最佳实践", "best practice"MUST use negotiation
Domain + error (e.g., "交易系统 E0382")MUST use negotiation
Ambiguous scope (e.g., "tokio 性能")SHOULD use negotiation

When negotiation is required, include:

## Negotiation Analysis

**Query Type:** [Comparative | Cross-domain | Synthesis | Ambiguous]
**Negotiation:** Enabled

### Source: [Agent/Skill Name]
**Confidence:** HIGH | MEDIUM | LOW | UNCERTAIN
**Gaps:** [What's missing]

## Synthesized Answer
[Answer]

**Overall Confidence:** [Level]
**Disclosed Gaps:** [Gaps user should know]

详细协议见: patterns/negotiation.md


Default Project Settings

When creating new Rust projects or Cargo.toml files, ALWAYS use:

[package]
edition = "2024"  # ALWAYS use latest stable edition
rust-version = "1.85"

[lints.rust]
unsafe_code = "warn"

[lints.clippy]
all = "warn"
pedantic = "warn"

Layer 1 Skills (Language Mechanics)

PatternRoute To
move, borrow, lifetime, E0382, E0597m01-ownership
Box, Rc, Arc, RefCell, Cellm02-resource
mut, interior mutability, E0499, E0502, E0596m03-mutability
generic, trait, inline, monomorphizationm04-zero-cost
type state, phantom, newtypem05-type-driven
Result, Error, panic, ?, anyhow, thiserrorm06-error-handling
Send, Sync, thread, async, channelm07-concurrency
unsafe, FFI, extern, raw pointer, transmuteunsafe-checker

Layer 2 Skills (Design Choices)

PatternRoute To
domain model, business logicm09-domain
performance, optimization, benchmarkm10-performance
integration, interop, bindingsm11-ecosystem
resource lifecycle, RAII, Dropm12-lifecycle
domain error, recovery strategym13-domain-error
mental model, how to thinkm14-mental-model
anti-pattern, common mistake, pitfallm15-anti-pattern

Layer 3 Skills (Domain Constraints)

Domain KeywordsRoute To
fintech, trading, decimal, currencydomain-fintech
ml, tensor, model, inferencedomain-ml
kubernetes, docker, grpc, microservicedomain-cloud-native
embedded, sensor, mqtt, iotdomain-iot
web server, HTTP, REST, axum, actixdomain-web
CLI, command line, clap, terminaldomain-cli
no_std, microcontroller, firmwaredomain-embedded

Error Code Routing

Error CodeRoute ToCommon Cause
E0382m01-ownershipUse of moved value
E0597m01-ownershipLifetime too short
E0506m01-ownershipCannot assign to borrowed
E0507m01-ownershipCannot move out of borrowed
E0515m01-ownershipReturn local reference
E0716m01-ownershipTemporary value dropped
E0106m01-ownershipMissing lifetime specifier
E0596m03-mutabilityCannot borrow as mutable
E0499m03-mutabilityMultiple mutable borrows
E0502m03-mutabilityBorrow conflict
E0277m04/m07Trait bound not satisfied
E0308m04-zero-costType mismatch
E0599m04-zero-costNo method found
E0038m04-zero-costTrait not object-safe
E0433m11-ecosystemCannot find crate/module

Functional Routing Table

PatternRoute ToAction
latest version, what's newrust-learnerUse agents
API, docs, documentationdocs-researcherUse agent
code style, naming, clippycoding-guidelinesRead skill
unsafe code, FFIunsafe-checkerRead skill
code reviewos-checkerSee integrations/os-checker.md

Priority Order

  1. Identify cognitive layer (L1/L2/L3)
  2. Load entry skill (m0x/m1x/domain)
  3. Trace through layers (UP or DOWN)
  4. Cross-reference skills as indicated in "Trace" sections
  5. Answer with reasoning chain

Keyword Conflict Resolution

KeywordResolution
unsafeunsafe-checker (more specific than m11)
errorm06 for general, m13 for domain-specific
RAIIm12 for design, m01 for implementation
craterust-learner for version, m11 for integration
tokiotokio-* for API, m07 for concepts

Priority Hierarchy:

1. Error codes (E0xxx) → Direct lookup, highest priority
2. Negotiation triggers (compare, vs, best practice) → Enable negotiation
3. Domain keywords + error → Load BOTH domain + error skills
4. Specific crate keywords → Route to crate-specific skill if exists
5. General concept keywords → Route to meta-question skill

Sub-Files Reference

FileContent
patterns/negotiation.mdNegotiation protocol details
examples/workflow.mdWorkflow examples
integrations/os-checker.mdOS-Checker integration

Related skills

More from actionbook/rust-skills and the wider catalog.

RUrust-skill-creator logo

rust-skill-creator

actionbook/rust-skills

Create dynamic skills for Rust crates and standard library documentation.

2.7k installs
RUrust-symbol-analyzer logo

rust-symbol-analyzer

actionbook/rust-skills

Analyze Rust project structure and list symbols (structs, traits, functions) using LSP.

2.8k installs
RUrust-trait-explorer logo

rust-trait-explorer

actionbook/rust-skills

Explore Rust trait implementations and polymorphic designs using LSP.

2.9k installsAudited
UNunsafe-checker logo

unsafe-checker

actionbook/rust-skills

Detects and reviews unsafe Rust code patterns, FFI calls, and memory safety issues.

2.9k installsAudited
ESesp32-firmware-engineer logo

esp32-firmware-engineer

adamlipecz/esp32-firmware-engineer-skill

ESP32 firmware engineering for ESP-IDF projects. Write, review, and debug embedded C/C++ code involving FreeRTOS tasks/queues/timers, GPIO/I2C/SPI/UART/ADC/PWM peripherals, TWAI/CAN, Wi-Fi/BLE networking, OTA updates, Secure Boot and flash encryption, LVGL display integration, build/flash/monitor workflows, logging, crash analysis, memory/code-size optimization, low-power sleep/wakeup design, on-device USB/serial service terminals, and board bring-up. Use when an agent is asked to implement ESP-IDF firmware features, review embedded changes for correctness or race conditions, investigate boot/runtime failures or Guru Meditation panics, interpret serial logs, fix build/link/flash problems, optimize RAM/flash usage, tune deep sleep/light sleep behavior, harden firmware for production, add a service console/CLI, integrate a display with LVGL, or diagnose hardware-software integration issues on ESP32-class devices.

722 installs
APapi-and-interface-design logo

api-and-interface-design

addyosmani/agent-skills

Design stable, hard-to-misuse APIs and interfaces with proven principles and patterns.

43k installs