rust-skills' routing table is the product, not the 31 skills

Trace up before you fix down

The stated problem is a small exchange. A developer reports a borrow checker error in a trading system and the assistant replies with a clone, which the README calls a surface fix that ignores domain constraints. The same example under the framework is laid out as a trace, and the trace is the whole idea. The error is an ownership error at the mechanics layer, so the router asks why the data is needed at all, and the answer comes from the domain: trade records are immutable audit data that should be shared rather than copied. Only then does the design layer offer a shared immutable value, and the mechanics layer names the type. The ordering matters more than the conclusion, because a clone is not wrong, it is a decision made without the information that would rule it out. The instruction at the top of the framework section is the compact version of the same claim: do not answer directly, trace through the cognitive layers first. Whether the trace is always right is a separate question, and it depends entirely on which domain skill happens to be loaded.

The routing table decides where you start

A three-layer model is a philosophy until something maps signals onto it, and the routing table does that. Four rows, each naming a user signal, an entry layer, a direction and a group of skills. An E0xxx compiler error starts at layer 1, the mechanics, and traces up, using the m01 to m07 skills. A question that begins with how to design starts at layer 2 and traces in both directions, using m09 to m15. A question about developing an app in a named domain starts at layer 3 and traces down, using the domain-prefixed skills. A performance question goes up and then back down, landing on m10-performance. The two axes doing the work are the phrasing of the question and the direction of the trace, and getting them wrong is the failure mode: a design question answered from the mechanics layer is a recipe, and a domain question answered from the design layer is a pattern with no constraints attached. The skill identifiers in that table are the only index of the 31 skills the README mentions, and the grouping tells you that the m-numbered skills are the general Rust body and the domain-prefixed ones are the extensions.

Skills-only gives you the content, the plugin gives you the router

The feature comparison table is the document to read before installing, because the two modes are not the same product. All three installation routes for skills-only, whether through npx, through CoWork or by copying files, give you all 31 skills, background agents with an inline fallback, and updates that are easy when the install came from a package tool. What they do not give you is the auto meta-cognition trigger or hook-based routing, both marked as absent, and the README says so in words: skills-only mode does not include hooks, so meta-cognition will not trigger automatically, and you invoke /rust-router or a specific skill yourself. The plugin modes, from a marketplace or from a local plugin directory, add the hooks and the automatic trigger, and they work only in Claude Code, so the table marks them as not working with other agents. The update story differs again: a locally cloned plugin directory has no easy updates, which is the one cell in that table that costs you something concrete. OpenCode and Codex are supported through their own installation documents in the repository, and the same skills-only caveat about manual invocation applies to them.

The main feature needs a browser and a shell permission

One of the listed features is real-time information, fetching the latest Rust versions and crate information through background agents, and there is a second listed feature that generates skills dynamically from your Cargo.toml dependencies. Both of those need the outside world, and the repository is explicit about what that means in practice. There are two dependent tools. actionbook is an MCP server for website action manuals, used by the agents to fetch structured web content such as Rust releases, crate information and documentation. agent-browser is a browser automation tool for fetching real-time web data, described as the fallback when actionbook is not available. Skills that cannot use the agent files fall back to inline execution with the built-in tools instead, which is a resilience design rather than a convenience. The permission cost is the part to notice. Background agents require permission to run agent-browser, so you copy the example configuration into your project or create a settings file that allows a Bash pattern for it. Granting a shell pattern to a browser automation tool is a real decision, and it is the price of the feature that keeps the assistant from answering from memory.

Three install routes, and what each one commits you to

The simplest route is a single command that adds the skills to whatever agent is driving them:

npx skills add actionbook/rust-skills

The second is a Rust tool of its own, CoWork, installed from crates.io, which offers version management, dependency resolution, lock files and security auditing. It installs a skill directly or from a configuration file that it generates, and that file is the most interesting artefact in this section because it has a security section:

[project]
name = "my-rust-project"

[skills.install]
rust-skills = "actionbook/rust-skills"

[security]
trusted_authors = ["ZhangHanDong"]

A trusted author list is a supply chain concept applied to prompt content, which is the right shape for a system that installs instructions into your editor. The third route is manual and is what you do when you want to read the files first:

git clone https://github.com/actionbook/rust-skills.git
cp -r rust-skills/skills/* ~/.claude/skills/

For the full plugin, the marketplace route is two slash commands, adding the marketplace and then installing the plugin from it, and the local route is a clone plus launching the agent with a plugin directory pointing at it. The repository also ships per-host installation documents for OpenCode and Codex, which tells you the author treats agent portability as a supported case rather than an accident.

Domain extensions are where the opinions live

The feature list names seven domain extensions: FinTech, machine learning, cloud native, IoT, embedded, web and CLI. Those are not neutral categories. A FinTech skill, judging from the framework's own worked example, will insist that records are immutable and shared, which is advice a real-time systems or embedded skill would give differently, and both would be right inside their own domain. The practical consequence is that installing all of them gives your agent a broader vocabulary and a wider spread of default answers, and the routing table tries to handle that by starting domain questions at layer 3 rather than layer 1. The layer model is also what lets a single skill set cover a web service and a firmware target, which is why the project can call itself a Rust development assistant rather than a Rust web assistant. What the documentation does not give you is a way to see which of the 31 skills a given project actually pulled in beyond the Cargo.toml-derived ones, so the practical first step after installing is to ask the agent which skills are loaded.

The repository tests its own triggers

The file list is more revealing than the feature list. Beyond the skills directory there are hooks, agents, commands, templates, references, an index directory, a metadata.json, a cache directory, a VERSION file, CHANGELOG.md, REVIEW.md, AGENTS.md, CLAUDE.md, an MCP configuration file, per-host directories for Claude Code, Codex and OpenCode, and an examples directory holding an achievement hooks configuration. Two entries stand out. test-triggers.sh and test-triggers.md are a test harness and its documentation for the routing table itself, which is the right thing to test in a system whose behaviour is a mapping from phrasing to layer, and it is a much better use of a test suite than asserting that a prompt file contains a certain string. The other is the setup.sh, which is presumably why the repository's primary language is recorded as Shell rather than Markdown. On versioning, the badge says 2.0.9 and the links point at a releases page that has no releases, and the root has no LICENSE file despite the MIT badge, so the licence text you would want to cite is not in the repository.

Against a conventions file and against a rules file you write yourself

The cheaper alternative is a conventions file in the repository, a CLAUDE.md or an equivalent, holding the style rules, the error patterns and the architectural boundaries. It is one file, you write it, and it survives any agent because it is prose the model reads anyway. Its weakness is exactly the one this project attacks: a flat list of rules has no ordering, so nothing stops the model from answering a domain question with a mechanics rule, and nothing records that a clone was the wrong answer. The other alternative is to lean on the tooling instead of the prompt, letting a compiler and a language server drive the agent so that an error is a fact rather than a symptom to be interpreted. That is stronger where the compiler can help and silent everywhere else, which is the design and performance half of the problem. What rust-skills offers that neither does is a maintained body of domain opinion you did not write, at the cost of a routing system you have to learn, external tools you have to permit, and domain extensions that will sometimes be confidently wrong for the project in front of you. For a team that has already written its own conventions, that trade is worth measuring before you make it.

Editorial conclusion

Adopt rust-skills if you write Rust with an agent daily and you keep seeing surface fixes, surface being a clone where a shared reference or a design change belonged, because the routing table is the part that changes behaviour. Do not adopt it if you want one opinion applied consistently, since the domain extensions will disagree with each other by design, FinTech wants immutable audit data and embedded wants something else. Verify four things before you install it: which of the two modes you are installing, because skills-only mode has no hooks and the routing is manual through /rust-router, whether you are willing to allow Bash(agent-browser *) in your project settings, what skills you actually need given that the set adapts to your Cargo.toml dependencies, and which skills you trust, since the CoWork configuration format has a trusted_authors list for exactly that reason. The badge says MIT, there is no LICENSE file at the repository root, the version is 2.0.9, there are no GitHub releases, and the last push was 2026-08-23.

Frequently asked questions

Official sources

1. actionbook/rust-skills on GitHub
2. Issues
3. README