domain-embedded

Use when developing embedded/no_std Rust. Keywords: embedded, no_std, microcontroller, MCU, ARM, RISC-V, bare metal, firmware, HAL, PAC, RTIC, embassy, interrupt, DMA, peripheral, GPIO, SPI, I2C, UART, embedded-hal, cortex-m, esp32, stm32, nrf, 嵌入式, 单片机, 固件, 裸机

Quality

41%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/domain-embedded/SKILL.md

Quality

Content

37%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill provides a solid reference card for embedded Rust constraints and patterns, with a good executable code example and useful comparison tables. However, it lacks actionable workflows (project setup, build, flash, debug sequences) and contains significant redundancy across its constraint/trace tables. It reads more like a cheat sheet than an instructional skill.

Suggestions

Add a concrete workflow section with sequenced steps: project setup (cargo generate/init with template), configure .cargo/config.toml and memory.x, build, flash with probe-run, and debug—with validation at each step.

Eliminate redundancy by consolidating the 'Domain Constraints → Design Implications', 'Trace Down', and 'Trace to Layer 1' sections into a single reference table, since they repeat the same constraint-to-implementation mappings.

Add actionable setup commands: e.g., `cargo install probe-run`, `cargo generate --git https://github.com/...`, target addition commands like `rustup target add thumbv7em-none-eabihf`.

Include a minimal but complete project structure example showing memory.x, .cargo/config.toml, and Cargo.toml configuration for a specific target.

Dimension	Reasoning	Score
Conciseness	The skill is reasonably efficient with tables and code blocks, but includes some redundancy—the 'Trace Down', 'Trace to Layer 1', and 'Domain Constraints → Design Implications' tables overlap significantly, repeating the same mappings (no heap → heapless, ISR safety → Mutex, etc.) in slightly different formats. The constraint boxes (RULE/WHY/RUST) are concise individually but duplicate what's already in the tables.	2 / 3
Actionability	The static peripheral code example is concrete and executable, which is good. However, much of the content is reference tables and abstract constraint descriptions rather than actionable instructions. Missing: how to set up a project (cargo commands, memory.x, linker scripts), how to flash, how to debug. The 'Layer Stack' and 'Framework Comparison' tables describe rather than instruct.	2 / 3
Workflow Clarity	There is no clear workflow or sequenced process for setting up or developing an embedded Rust project. No steps for project creation, building, flashing, or debugging. No validation checkpoints. The content is organized as reference material (tables and patterns) rather than a workflow. For embedded development—which involves multi-step processes with hardware—this is a significant gap.	1 / 3
Progressive Disclosure	The content references related skills (m02-resource, m03-mutability, etc.) and has a 'Related Skills' section, which is good. However, the references use internal layer numbering (Layer 1, Layer 2, Layer 3) without explaining the system, and there are no bundle files to support the references. The auto-injected project context command is a nice touch. The content itself could benefit from splitting detailed patterns into separate files.	2 / 3
	Total	7 / 12 Passed

Description

44%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

This description excels at trigger term coverage and distinctiveness with an impressive list of domain-specific keywords, but critically fails to describe what the skill actually does. It reads as a keyword index rather than a skill description — a user or Claude can identify when to use it, but has no idea what capabilities it provides (e.g., writing drivers, configuring peripherals, debugging firmware, setting up build systems).

Suggestions

Add concrete capability descriptions before the keyword list, e.g., 'Guides development of embedded/no_std Rust projects including peripheral configuration, driver implementation, interrupt handling, memory-mapped I/O, and firmware build setup.'

Restructure to clearly separate the 'what it does' from the 'when to use it' — currently only the 'when' clause exists with no substantive 'what' content.

Dimension	Reasoning	Score
Specificity	The description does not list any concrete actions or capabilities. It only states 'Use when developing embedded/no_std Rust' followed by a keyword list, but never describes what the skill actually does (e.g., configure peripherals, write drivers, set up interrupt handlers).	1 / 3
Completeness	The 'when' is present ('Use when developing embedded/no_std Rust'), but the 'what' is entirely missing — there is no description of what the skill actually does or what capabilities it provides. This makes it incomplete on the most fundamental level.	1 / 3
Trigger Term Quality	Excellent coverage of natural trigger terms users would say, including hardware platforms (ARM, RISC-V, esp32, stm32, nrf), protocols (SPI, I2C, UART), frameworks (RTIC, embassy), and even Chinese equivalents (嵌入式, 单片机). These are terms embedded developers naturally use.	3 / 3
Distinctiveness Conflict Risk	The embedded/no_std Rust niche is very specific and unlikely to conflict with other skills. The extensive keyword list of domain-specific terms (MCU, HAL, PAC, cortex-m, etc.) makes it clearly distinguishable from general Rust or general programming skills.	3 / 3
	Total	8 / 12 Passed

Validation

90%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: actionbook/rust-skills
Commit: fa60f79

Reviewed: 29 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.