actionbook/rust-skills
33 skills28.9k installs40.3k starsGitHub
Install
npx skills add https://github.com/actionbook/rust-skillsSkills in this repo
1Coding GuidelinesCoding Guidelines is an agent skill that encodes fifty prioritized Rust style and quality rules drawn from the community Rust coding guidelines, with a practical Clippy lint mapping so fixes are actionable instead of vague. Solo and indie builders shipping CLIs, APIs, or agent-side Rust tools can invoke it when naming feels inconsistent, fmt/clippy debates stall a PR, or an agent keeps emitting unwrap-heavy or non-idiomatic patterns. The skill emphasizes conventions that differ from other languages—avoiding get_ prefixes, standard iterator naming, explicit imports, and safety documentation for unsafe blocks—while deferring deep unsafe audits to the related unsafe-checker skill. It is a procedural reference, not a formatter binary: pair it with rustfmt and clippy in CI for enforcement. Use during active implementation and again during review when you want checklist-backed feedback without rereading hundreds of pages of the full Chinese/English guideline corpus.1kinstalls2M07 Concurrencym07-concurrency is an Actionbook Rust skill that teaches agents how to diagnose and design concurrent Rust before stacking Mutex wrappers or spawn_local patches. It sits at Layer 1 language mechanics and opens with a single decision: is the work CPU-bound or I/O-bound, and what actually needs to be shared? A fixed error-to-design-question table reframes E0277 Send/Sync, non-Send futures, and deadlock messages as architecture prompts. A three-part thinking checklist walks through workload type, sharing model (channels, Arc, locks), and Send/Sync requirements for cross-thread ownership versus references. Solo and indie builders shipping Rust APIs, CLIs, or agent tooling invoke it when the compiler complains about thread safety, when choosing between std::thread, rayon, tokio, or async-std, or when investigating race conditions and lock ordering. It is agent-oriented (user-invocable: false) and pairs with the broader rust-skills curriculum for systematic Rust fixes rather than one-off chat guesses.980installs3M10 PerformanceM10-performance is a Rust-focused agent skill from the actionbook rust-skills line that forces a disciplined optimization workflow instead of premature tweaking. It opens with the core question—what is the real bottleneck and whether speed is worth added complexity—and maps goals to concrete design choices such as pre-allocation, contiguous storage, parallelism with rayon, and zero-copy patterns. Triggers cover everyday builder language (slow, fast, allocation, cache, SIMD) plus profiling tooling names. The skill is marked CRITICAL for performance work and sits as Layer 2 design choices, with guidance to trace upward toward domain SLAs when deciding how fast is fast enough. Solo builders shipping CLI tools or services use it when criterion regressions fail, production latency spikes, or reviews suspect accidental clones and heap churn. It complements general coding skills by anchoring every suggestion in measurement and explicit trade-off tables rather than folklore micro-benchmarks.973installs4M06 Error HandlingM06 Error Handling is an Actionbook Rust skill that teaches how to split error strategy between libraries and applications. Solo builders shipping Rust CLIs or API crates get concrete patterns: define specific error enums instead of anyhow in public libraries, derive thiserror for Display and source(), expose matchable variants, and keep errors Send + Sync for async runtimes. The readme walks through a DatabaseError type with structured fields, #[source] chaining for I/O and SQL failures, and a crate-level Result alias consumers can rely on. That matters when agents otherwise sprinkle String errors or leak implementation details across module boundaries. Use it while authoring shared crates in Build, and again in Ship when hardening failure modes before release. It is instructional Rust prose rather than a CI checker; pair it with your project’s clippy and test suite. Confidence is high because the skill is narrowly scoped to error design with copy-pasteable templates.967installs5M01 OwnershipM01-ownership is a compact reference skill from the Rust skills series that explains Rust’s ownership model by contrasting it with C++ move/copy defaults and Go’s GC-centric sharing. Solo builders shipping Rust CLIs or APIs use it when the borrow checker blocks a design and they need the mental model fast—not abstract rules in isolation. The skill emphasizes what changes after a move (invalidation in Rust versus underspecified but compiling C++), maps smart pointers to familiar C++ types, and contrasts Go’s nil and channels with Option and Send/Sync-aware sharing. It is instructional reference material, not a linter or refactor bot; pair it with your crate’s actual types and error messages when implementing concurrency or shared state.961installs6M02 Resourcem02-resource is a Rust agent skill from the actionbook rust-skills set that stops solo builders from cargo-culting smart pointers. Whenever compile errors or design doubts mention Box, Rc, Arc, Weak, RefCell, or Cell, the skill reframes the problem: single versus shared ownership, single-threaded versus multi-threaded access, and whether reference cycles force Weak. It is written as language mechanics Layer 1 guidance with an error-to-question table so the agent asks why stack allocation failed or whether runtime borrow checks are the right tradeoff instead of blindly suggesting try_borrow. The readme marks user-invocable false, meaning it is typically pulled by the Rust skills router when triggers fire—but Prism still tags it so builders discover structured ownership help inside Claude Code, Cursor, or Codex sessions. Use it across Build and Ship when refactoring graphs, sharing config across tasks, or debugging RefCell panics, and during Operate when production leaks hint at Rc cycles.960installs7M05 Type Drivenm05-type-driven is a Rust agent skill from the actionbook stack that teaches type-driven design so invalid states never compile. Solo builders shipping CLIs, APIs, or SaaS backends invoke it when a design drifts toward strings, booleans, and runtime validation that the compiler could enforce instead. The skill centers on one question: how can the type system prevent invalid states? It walks through when to prefer bounded or newtyped values, type-state transitions, sealed traits, and clear construction boundaries versus when Result-backed runtime checks remain appropriate. Triggers cover PhantomData, marker traits, compile-time validation, and common anti-patterns like primitive obsession. It is marked CRITICAL in metadata and is not user-invocable by default—agents should attach it during Rust design and refactor discussions. Use it across implementation and review whenever invariants belong in types, not scattered if-checks.958installs8M03 Mutabilitym03-mutability is a Rust language-mechanics skill aimed at solo builders who hit mutability and borrow checker errors and are tempted to sprinkle mut or RefCell without a design rationale. It is tagged for Build backend work as the canonical shelf because that is where APIs, shared state, and concurrent access get shaped, but it remains useful whenever compilation blocks progress in Ship. The skill reframes compiler errors such as E0596 cannot borrow as mutable, E0499 already borrowed, and E0502 conflicting borrows into questions about whether mutation is essential, who should own it, and whether the context is single- or multi-threaded. It contrasts external &mut T with interior Cell, RefCell, Mutex, RwLock, and atomics, and warns that RefCell panics signal a modeling problem—not just missing try_borrow. Use it with your agent when debugging ownership before rewriting large structs blindly.948installs9M04 Zero CostM04 zero-cost is a Rust-focused agent skill from the actionbook layer that reframes trait and generic errors as architecture questions instead of quick fixes. Solo builders shipping CLIs, APIs, or systems code hit E0277 trait bound not satisfied, E0308 mismatched types, and E0599 method not found when abstraction levels disagree; this skill walks through whether compile-time monomorphization or runtime trait objects fit the collection shape and performance goals. It is marked non–user-invocable in metadata but still acts as procedural knowledge the agent should load when those triggers appear. Placement on the build backend shelf is canonical because that is where generics and traits are authored, yet the same reasoning applies during ship review and operate debugging when production binaries fail to compile after refactors. Intermediate complexity reflects real Rust type-system literacy. The outcome is a coherent choice among trait, enum, and concrete representations with dispatch strategy aligned to when types are known, not a pile of copy-pasted bounds.947installs10M09 DomainM09 Domain is an agent skill for solo builders implementing domain-driven design in Rust services or CLIs who need consistent answers before writing structs and traits. It frames the core question—what role does each concept play—then maps entities with stable ids, interchangeable value objects, aggregate roots that own children, repositories as traits, domain events as enums, and stateless services as impl blocks or free functions. The prompts force you to decide identity needs, invariants that must always hold, and who owns data in the tree, including when Arc or weak references apply. That reduces the common failure mode of anemic models and leaked persistence logic across layers. Use it when refactoring a growing backend, introducing bounded contexts, or aligning agent-generated Rust with real DDD boundaries. It complements lower-level Rust skills on errors and async by sitting at the design layer where business rules meet type layout.944installs11M15 Anti PatternThe m15-anti-pattern skill packages actionable Rust mistake patterns for solo builders shipping CLIs, APIs, or backend services who want the agent to steer away from habits that fight the borrow checker or hide failures. It walks through ownership traps such as cloning entire collections to placate the compiler, boxing values without need, and extending borrows across mutations that invalidate references. Each anti-pattern pairs with a minimal better alternative so you can apply the fix in place during implementation or review. The error-handling portion focuses on production readiness: replacing pervasive `unwrap` and `expect` with `Result` propagation so callers decide how to surface I/O and parse failures. You invoke it when drafting new modules, cleaning up agent-generated Rust, or preparing ship-phase review where panic paths are unacceptable. It is reference procedural knowledge—not a linter replacement—meant to complement `cargo clippy` and tests by teaching the why behind common rustc errors and fragile APIs.938installs12M12 Lifecyclem12-lifecycle is a Rust agent skill for solo builders designing how expensive or scoped resources are created, used, and torn down. It frames resource lifecycle as a Layer 2 design choice: you decide scope, ownership of cleanup, and behavior on errors before touching implementation. A pattern table ties RAII to Drop, lazy initialization to OnceLock and LazyLock, reuse to pools like r2d2 and deadpool, scoped access to guard patterns, and transactional boundaries to custom Drop structs. Thinking prompts walk you through whether resources are cheap per-use, request-scoped, or application-wide, and whether cleanup must run on failure. Use it when wiring connection pools, sessions, or global singletons in APIs and CLIs so agents do not leak handles or fight the borrow checker with ad-hoc close calls. It complements broader Rust architecture skills by focusing narrowly on when cleanup runs and who owns it.924installs13M14 Mental Modelm14-mental-model is a journey-wide Rust literacy skill from the actionbook rust-skills series. It teaches solo builders the three pillars the compiler enforces—ownership as sole responsibility for freeing resources, borrowing as temporary lending without stealing ownership, and lifetimes as compile-time proof that references remain valid—using short prose and illustrative snippets rather than a full crate scaffold. You reach for it whenever Rust fights your intuition: borrow checker errors, API signatures that need &str versus String, or returning references from helpers. The canonical Prism shelf is Build backend because that is where most indies first ship Rust services or CLIs, but the same models apply during Validate prototypes, Ship review when fixing unsound-looking code, and Operate when patching production Rust. The skill is conceptual reference material, not a linter or codegen tool; pair it with hands-on coding tasks when you want explanations grounded in “who owns this value?” instead of generic stackoverflow paraphrases.921installs14M13 Domain Errorm13-domain-error is a Rust-focused agent skill for designing domain error handling as a deliberate architecture choice, not an afterthought. It walks solo and indie builders through categorizing failures by audience—end users, developers, and operations—and by recoverability, from transient network blips to permanent data corruption. Before you add another `thiserror` variant, the skill asks who sees the message, whether automation can retry, and what context must survive for logs and alerts. That framing fits API services, CLIs, and SaaS backends where one wrong error type either leaks internals or blocks sensible retries. Use it while shaping crates and service boundaries in build, again during ship when reviewing failure paths, and in operate when tuning alerts and degradation. It complements Rust implementation skills by keeping error hierarchies consistent with how humans and systems actually respond.916installs15Unsafe CheckerUnsafe Checker is an agent skill for solo builders and small teams maintaining Rust crates that use unsafe for FFI, allocators, or hot paths. It surfaces a quick-reference rule set organized into General Principles, Safety Abstraction, and Raw Pointers sections, each with prioritized (P) and guideline (G) entries. Invoke it when auditing new unsafe blocks, public raw-pointer APIs, or manual Send/Sync implementations so invariants, documentation, and panic safety are explicit. The skill pushes SAFETY comments before blocks, safe/unsafe API pairing for performance, and NonNull over bare *mut T. It fits the Ship review subphase but also supports Build when authoring unsafe the first time. Outcomes are fewer latent aliasing, uninitialized memory, and double-free risks before production.909installs16M11 Ecosystemm11-ecosystem is a Rust-focused agent skill for solo builders who hit dependency paralysis or mysterious import errors mid-project. It frames ecosystem choices as design decisions: which serde stack, which async runtime, which HTTP server, and whether anyhow or thiserror fits your crate boundary. The skill pulls live dependency context from Cargo.toml when available so advice matches your tree instead of generic lists. It also spans FFI and bindings (PyO3, WebAssembly, napi-rs) when your product crosses language lines. Invoke it when compiler errors mention missing crates, private modules, or when you are comparing axum versus actix-web for a small API. The outcome is a defensible Cargo.toml change with feature flags and workspace structure that stays maintainable as you ship and iterate.905installs17Rust Refactor HelperRust Refactor Helper is an agent skill for solo and indie builders maintaining Rust codebases who want renames and structural moves without missing call sites. It wraps a repeatable workflow: locate the symbol with LSP, enumerate every reference, group impact by file, then apply rename, extract-to-function, inline, or move-to-module operations—with an optional dry-run before writes. Triggers include /refactor, rename symbol, move function, extract, and related phrases in English and Chinese. It fits Claude Code, Cursor, and similar agents that expose LSP plus read/edit tools on a local repo. Use it during active backend work when APIs or types need consistent renaming or when logic should be extracted or relocated; pair with normal compile/test runs after edits because it does not replace cargo check or CI.882installs18Rust Code NavigatorRust-code-navigator is an agent skill for indie builders maintaining Rust backends, CLIs, or agent tooling who need IDE-grade navigation without leaving the chat session. It wraps Language Server Protocol operations—go to definition, find references, and hover—with a simple invocation pattern: pass a symbol name and optionally a file and line when the codebase has duplicates. The documented workflow maps user intent to the right LSP call, including when to prefer references before a rename and when hover is enough for type checking. Allowed tools are LSP, Read, and Glob, so the agent can orient in multi-crate workspaces typical of solo Rust projects. It fits the Build/backend shelf because the payoff is faster comprehension of structs, traits, and functions while implementing features or reviewing impact, not running production monitors or writing marketing copy. Intermediate complexity assumes you already run rust-analyzer or compatible LSP in your editor-linked agent environment.880installs19Rust Call Graphrust-call-graph is an agent skill for solo builders maintaining Rust backends, CLIs, or agent tooling who need fast answers about control flow without manually clicking through every reference. It drives the language server’s call hierarchy to show incoming callers, outgoing callees, or both, with configurable depth and direction flags documented in the SKILL workflow. Typical use is after landing in an unfamiliar handler—process_request, handle_error, or main—and needing to see blast radius before a refactor or bugfix. It pairs Read and Glob with LSP operations only, so it fits Claude Code or Cursor environments where rust-analyzer is already wired. The skill is narrow by design: it visualizes relationships; it does not replace tests or profiling.870installs20Rust Symbol AnalyzerRust Symbol Analyzer is an agent skill that maps Rust project structure using Language Server Protocol symbols rather than grep alone. Solo builders and small teams use it when onboarding to an unfamiliar crate, planning refactors, or answering “what traits exist here?” without reading every module. It supports whole-workspace scans via workspaceSymbol, focused file views via documentSymbol on paths like src/lib.rs, and filtering by symbol kind (struct, trait, fn, mod). The documented workflow finds Rust files with Glob, pulls symbols from anchor files, categorizes by type, and emits a structure summary. It requires an agent environment where LSP, Read, and Glob tools are allowed—typical in Cursor-style setups with rust-analyzer. It does not run tests, format code, or change files; it is read-only navigation aid for Build and Ship review prep.868installs21Rust Trait Explorerrust-trait-explorer helps solo builders navigate Rust polymorphism without manually ripgrep-ing every impl block. Given a trait, it uses workspace symbols and go-to-implementation to enumerate concrete types and then document symbols for method surfaces. Given a struct, it combines definition lookup with impl-for pattern search to produce a trait inventory. The skill is procedural: fixed LSP operations, when to use each, and example invocations in English and Chinese trigger phrases. It suits indie maintainers onboarding to unfamiliar crates, auditing extension points before adding a new Handler, or reviewing generic bounds. It does not replace compiling or running tests—it accelerates reading the type graph inside the editor agent.866installs22Domain Clidomain-cli is a Layer 3 Rust domain skill for solo builders and small teams writing command-line tools. It translates ergonomic CLI expectations—clear help, predictable configuration order, proper exit codes, separable stdout/stderr, and interrupt handling—into concrete Rust patterns using clap derive macros, layered config loading, and disciplined error output. The skill is invoked when an agent is editing or scaffolding a CLI crate so design choices stay aligned with pipeability and shell scripting rather than ad-hoc println debugging. It complements type-driven and architecture layers in the same rust-skills pack by tracing requirements like argument parsing down into struct-derived CLI definitions. Use it during active implementation of terminals, TUIs, and internal dev tools where misconfigured I/O or exit semantics would break CI and user scripts.864installs23Meta Cognition ParallelMeta-cognition parallel is an experimental Rust skill that coordinates three parallel cognitive layers—language mechanics, design choices, and domain constraints—then synthesizes them into one architectural answer. Solo builders invoke it when a single-pass agent reply feels shallow on ownership, traits, performance, or domain rules, and they want structured depth without manually prompting each angle. The coordinator can fan out analyzers in agent mode or fall back to sequential inline execution before cross-layer synthesis in the main context. It is tagged multi-phase because the same ritual helps during backend implementation, ship-time design review, and operate-phase debugging of Rust services. It is not a code generator; it is a research-style workflow for hard Rust questions where tradeoffs span syntax, API shape, and problem-domain limits.851installs24Rust LearnerRust Learner is an agent skill for solo and indie builders shipping Rust services, CLIs, or agent tooling who need accurate, up-to-date toolchain and crate facts instead of guessing versions from memory. It centers on version queries, API documentation from docs.rs, and Rust release changelogs, with Clippy lint research as a related path. The skill picks an execution mode by checking whether plugin agent files exist, then delegates to crate, changelog, standard-library, third-party docs, or Clippy researcher workflows. It is meant as the primary fetch path for Rust and crate information during implementation, dependency upgrades, and pre-ship compatibility checks. Triggers include questions about stable versus nightly, editions, cargo add/update, and multilingual phrasing around “latest version” and crate metadata.846installs25Domain Webdomain-web is a Rust Layer 3 domain-constraint skill for solo and indie builders shipping HTTP services with ecosystems like axum, actix, tower, and hyper. It does not replace framework docs; it translates operational realities—many concurrent connections, latency expectations, and untrusted input—into non-negotiable design habits. The skill stresses async handlers that never block the runtime, thread-safe shared state behind Arc, and resources that live only for the request lifetime through extractors. Security and operability are framed as type-level and middleware concerns: validated extractors, auth patterns, and tracing integrated via tower. Use it when scaffolding or reviewing a web crate so concurrency, ownership, and SLA-minded structure stay consistent before you accumulate blocking calls or leaky global state.840installs26Rust DailyRust Daily is a research-oriented agent skill that compiles Rust ecosystem updates for solo builders who need a fast briefing instead of manually opening Reddit, This Week in Rust, and official blogs. It responds to explicit triggers such as rust news, TWIR, rust daily or weekly, and Chinese Rust 日报/周报 phrasing, and it filters output by day, week, or month with optional category focus (ecosystem, official, or foundation). When the plugin ships the rust-daily-reporter agent file, the skill delegates through a structured Task workflow; in skills-only installs it falls back to inline fetches, including browser-based reads of hot Reddit posts via agent-browser CLI patterns documented in the skill. That split keeps the same user outcome whether or not the full plugin layout is present. Use it in early journey phases when choosing crates, tracking language releases, or explaining Rust momentum to yourself or stakeholders—without turning research into a half-day tab hunt.828installs27Rust Deps VisualizerRust Dependencies Visualizer is an agent skill for solo builders shipping Rust binaries, libraries, or CLIs who need a fast mental model of transitive crates without opening a GUI graph tool. It shells out to cargo metadata and cargo tree, then formats the result as terminal-friendly ASCII art with optional depth limits and feature-aware labels. Use it when onboarding to an unfamiliar repo, debating whether to drop a heavy dependency, or explaining supply-chain surface to yourself before a security pass. The skill expects Bash access to run cargo commands in the project root and Read/Glob to locate manifests. It does not replace cargo deny or audit workflows; it makes the tree legible in chat so your agent can reason about versions and feature bundles alongside you.822installs28Rust Skill CreatorRust Skill Creator is a meta agent skill from the Actionbook Rust skills line that turns official Rust documentation into reusable agent capabilities. Solo builders maintaining Claude Code, Cursor, or Codex setups can request skills for crates like tokio or serde or for std items such as Send, and the skill routes those requests to the right docs.rs or rust-lang.org endpoints before invoking LLM-assisted skill generation commands when the full plugin is installed. It detects whether create-llms-for-skills and create-skills-via-llms are available, branching between Agent Mode automation and slimmer environments. The outcome is dynamic, documentation-grounded SKILL packages instead of hand-copied API cheatsheets that go stale. Use it whenever you extend your agent toolbox for Rust backends, CLIs, or embedded services, and especially when onboarding new dependencies during Build or when refreshing Operate-era maintenance docs. Anti-pattern: expecting it to write application business logic—it produces skill artifacts, not production crates.821installs29Domain Cloud Nativedomain-cloud-native is a Layer 3 domain constraint skill in the Actionbook Rust stack: it translates cloud-native expectations—Kubernetes deployments, Docker images, gRPC services, service meshes, and production observability—into concrete Rust design implications. Solo builders shipping Rust APIs or workers to K8s get a checklist mindset instead of bolting on ops concerns late: configuration from environment variables, liveness and readiness probes as first-class endpoints, zero reliance on pod-local mutable state, and graceful termination so rolling updates do not drop in-flight work. The skill points downward into lifecycle and tracing modules rather than teaching cloud from scratch; it is a constraint lens for code review and architecture passes. Marked user-invocable false in metadata but valuable in catalogs for agents composing full Rust skill trees. Intermediate complexity assumes familiarity with async Rust and basic container deploy flows.735installs30Domain Mldomain-ml is a reference skill in the actionbook Rust skills family that encodes machine-learning domain rules as design constraints for Rust implementations. Solo builders shipping on-device inference, ONNX-served APIs, or batch analytics workers use it so agents do not treat Rust ML like Python notebooks—large tensors demand zero-copy views, GPU work needs batching, and portability often means ONNX via candle or tract. The document links upward from constraints to modules such as performance and concurrency, and names ecosystem anchors including ndarray, candle, tch-rs, burn, and polars lazy pipelines. It is multi-phase because the same constraints appear when you Validate a prototype benchmark, Build the service, Ship performance tests, and Operate production inference. Complexity is advanced: you are expected to reason about f32/f64 precision, seeded randomness, and kernel launch overhead. Invoke it when keywords match ML, inference, neural networks, or Chinese equivalents in mixed-language prompts. Prism files it under Data Science & ML with a research/meta pattern because it shapes architecture rather than executing a single CLI task.725installs31Domain Embeddeddomain-embedded is a Layer 3 domain constraint skill for actionbook’s Rust skills pack. It targets solo and indie builders shipping no_std firmware on microcontrollers where heap allocation and std are unavailable. Invoke it when you or your coding agent touch Cargo.toml or .cargo/config.toml on embedded targets and need predictable timing, minimal RAM, and safe GPIO, SPI, I2C, UART, DMA, and interrupt handling. The skill translates bare-metal realities into Rust choices: #![no_std], heapless::Vec, static buffers, RTIC or Embassy-friendly patterns, and embedded-hal traits. It is not a flashing or CI tutorial; it is procedural guardrails so agent suggestions do not reintroduce dynamic allocation or blocking ISR code. Pair it with broader Rust skills in the same repo for general language rules.707installs32Domain FintechDomain FinTech is a Rust-oriented agent skill from the Actionbook domain layer. It translates regulatory and accounting realities into concrete design constraints: money must not use floating point, transaction records should be immutable and traceable, totals must balance, and execution should stay deterministic for reproducible trading or ledger behavior. Each rule pairs a WHY with a RUST implication—rust_decimal for precision, Arc for shared immutable data, structured tracing for compliance logs, and clear transaction boundaries for consistency. Solo builders shipping payment flows, exchanges, or internal ledgers in Rust can invoke it whenever the model risks silent precision loss or mutable history. It is not a full compliance checklist; it keeps the agent anchored on foundational fintech engineering mistakes. Pair it with your crate’s architecture skills for ownership and type-driven modeling when drilling from constraints into code structure.700installs33Domain Iotdomain-iot is a Rust domain-constraints skill from the actionbook stack: it tells your agent how real-world IoT rules should shape code before you pick crates and modules. Solo builders shipping sensors, gateways, or smart-home backends often underestimate flaky wireless, battery budgets, and physical tampering—this skill translates those constraints into explicit design choices (local buffering, backoff retries, TLS and signed messages, watchdog recovery, OTA with rollback). It traces recommendations downward to other layers in the family (lifecycle persistence, domain errors, embedded no_std, performance minimization) so planning stays consistent. Use it when scoping or implementing Rust IoT services during Build, and revisit during Operate when you harden monitoring and recovery. It is reference constraints, not a full MQTT broker installer or cloud dashboard generator. Pair it with embedded-specific Rust skills when targets are microcontrollers rather than edge Linux.675installs