zhanghandong/rust-skills
34 skills28.4k installs41.5k starsGitHub
Install
npx skills add https://github.com/zhanghandong/rust-skillsSkills in this repo
1M15 Anti Patternm15-anti-pattern is a Rust-focused agent skill for reviewing code through a design-choice lens rather than style nitpicks. Solo and indie builders shipping CLIs, services, or libraries in Rust install it when they want the agent to ask whether a pattern is treating a symptom or the underlying ownership or API design problem. The skill encodes a compact table of frequent mistakes—indiscriminate clone and unwrap, unnecessary Rc, convenience unsafe, trait misuse via Deref, oversized match arms, String allocation habits, and dropped must_use results—and pairs each with a more idiomatic direction such as references, proper error propagation, composition, and Cow. It is meant to be pulled during review passes or when you are unsure if a workaround is fighting Rust. Confidence is high for review workflows; it does not replace automated tests or security audits.5.5kinstalls2Coding Guidelinescoding-guidelines is a Prism agent skill that encodes fifty high-signal Rust style and quality rules from the Rust Coding Guidelines, so solo and indie builders shipping CLI tools, APIs, or agent-side Rust crates get consistent answers about naming, formatting, comments, Clippy lints, and common anti-patterns without rereading the full 500+ rule book. Invoke it when you or your agent are drafting modules, reviewing a diff, or asking how to replace unwrap with ?, fix needless_clone, or document unsafe blocks. It complements automated rustfmt and cargo clippy in CI by giving procedural, rule-ID-aligned rationale an LLM can apply in chat-driven workflows across Claude Code, Cursor, and Codex. For unsafe-heavy code paths, the skill explicitly routes you to the companion unsafe-checker skill. It is reference and checker oriented—not a codegen scaffolder—optimized for day-to-day consistency on small teams where one person owns Rust quality end to end.1.2kinstalls3M10 Performancem10-performance is a Rust performance optimization guide for solo builders and small teams shipping backends, CLIs, or APIs. It insists on profiling before micro-optimizing: install flamegraph for CPU, use heaptrack or cargo-instruments for memory, run criterion benchmarks, and optionally cachegrind for cache behavior. The skill then walks concrete patterns—returning `Cow` to skip allocations when data is already in the desired shape, and reusing growable buffers across iterations instead of creating a fresh `Vec` every time. It is meant for agents and developers who already have a Rust crate and need repeatable measurement, not vibes. Use it when latency or allocation churn shows up in production or release builds, or when you are choosing between two implementations and want criterion to decide. It does not replace domain-specific algorithm design; it makes sure you measure and apply Rust-idiomatic fixes that actually move numbers.858installs4M07 ConcurrencyM07 Concurrency is a Rust-focused agent skill from a layered skills pack that forces a design-first answer before you sprinkle async or mutexes on a type error. It centers on one question: is the work CPU-bound or I/O-bound, and what actually needs to be shared? For solo builders shipping Rust APIs, CLIs, or tokio services, it translates familiar pain—E0277 Send and Sync, futures that are not Send, channel versus shared mutable state, atomics, and deadlock scares—into explicit tradeoffs between std::thread, rayon, tokio, and hybrid approaches. The skill is not a codegen shortcut; it is procedural knowledge that pairs compiler messages with mandatory trace-up reasoning so agents do not default to Arc<Mutex<Everything>>. Install it when your agent is editing concurrent Rust and you want consistent vocabulary around thread safety, async boundaries, and sharing models.803installs5M06 Error Handlingm06-error-handling is a Rust agent skill focused on how solo builders should split error strategy between libraries and binaries. It walks through defining explicit error enums with thiserror, implementing std::error::Error for interoperability, preserving source errors for debugging, and keeping types Send + Sync for async stacks. The included database-oriented example demonstrates connection failures, query failures, not-found cases, and constraint violations with structured fields instead of stringly-typed messages. For indie builders shipping CLI tools, internal services, or open-source crates, the skill is the shelf reference when you want callers to branch on failure modes while still using ergonomic ? propagation inside the crate. Use it while designing public APIs, hardening a library before publish, or refactoring ad-hoc String errors into typed variants. It does not replace broader Rust async or observability setup; it tightens the error boundary that every downstream integration depends on.779installs6Rust Refactor HelperRust Refactor Helper is an agent skill that makes large-scale Rust edits safer for solo builders maintaining crates, CLIs, or backend services. Instead of blind search-and-replace, it drives LSP operations—find references, go to definition, hover, and incoming call hierarchy—to map blast radius before rename, extract-function, inline, or move-to-module workflows run. You invoke actions like renaming parse_config to load_config or extracting a line range into a new function with an optional dry-run when you want a report without touching disk. The skill targets intermediate Rust users who already have rust-analyzer wired in their editor agent. It stays in the Build phase because its value is day-to-day structural hygiene: keeping modules coherent as features land, not pass/fail security or launch checklists. Outputs are applied edits (or a dry-run plan) grounded in reference data rather than heuristic guesses.773installs7M01 Ownershipm01-ownership is a reference skill from the rust-skills collection that teaches Rust’s ownership model by comparing it to C++ and Go. Solo builders shipping CLI tools, APIs, or agents in Rust use it when assignments, clones, or thread sharing produce borrow-checker errors they cannot interpret from compiler messages alone. The skill walks through move semantics (where the source binding becomes invalid), explicit clone for copies, and how Box, Rc, Arc, and RefCell relate to familiar C++ smart pointers and Go’s GC model. It is not a full Rust course—it is targeted comparison material you invoke while coding so your agent suggests patterns that compile and match your performance goals. Pair it with other rust-skills modules as you progress through larger backend features.763installs8M04 Zero Costm04-zero-cost is a Rust agent skill from the rust-skills series that teaches zero-cost abstraction as a design choice, not a syntax checklist. Solo and indie builders shipping CLI tools, APIs, or embedded Rust hit trait-bound and type-mismatch errors constantly; this skill reframes those diagnostics as questions about whether abstraction belongs at compile time or runtime, and whether enums or concrete types would be simpler. It walks through when to prefer generics for performance and monomorphization versus trait objects for heterogeneous collections, and when object safety forces a rethink of dynamic dispatch. The layer is explicitly language mechanics, so it pairs well with an agent already editing Rust sources in Claude Code, Cursor, or Codex. Use it when errors mention generics, traits, impl Trait, or dispatch model confusion—not when the task is pure DevOps or non-Rust stacks. The outcome is a deliberate polymorphism strategy that compiles without piling on bounds that obscure intent.753installs9M05 Type Drivenm05-type-driven teaches Rust solo builders to let the type system carry invariants instead of defaulting to strings, booleans, and late Result checks. The skill frames every smell—primitive obsession, flag enums, permissive Option—as a design question: can invalid states be unrepresentable, can transitions be typed, and should the compiler or API consumers enforce the rule. It walks through newtypes for semantic meaning, type state for legal transitions, bounded representations for numeric ranges, and sealed traits when extension must be controlled. Triggers span English and Chinese so agents attach it during refactors and greenfield module design. Use it while implementing backends, CLIs, and APIs where correctness matters and runtime validation noise would hide bugs until production. It pairs naturally with broader Rust skills in the same repo but stands alone as the type-level design lens.747installs10M02 Resourcem02-resource is a Rust language-mechanics skill that helps solo builders decide which smart pointer and ownership pattern fits a piece of data before writing code. Instead of defaulting to Box or Arc, it walks through whether ownership is single or shared, whether access is single-threaded or multi-threaded, and whether reference cycles require Weak on one edge. The skill reframes common compiler frustrations and runtime RefCell panics as design questions—why heap allocation, whether the cycle is necessary, and whether multi-thread Arc overhead is justified. It fits indie builders shipping CLIs, APIs, or agent-side Rust services who want consistent RAII thinking without memorizing every pointer type. Use it during implementation and again when debugging ownership leaks or Arc-heavy hot paths in production-minded code.744installs11M03 Mutabilitym03-mutability is a Rust-focused agent skill that treats mutability as a design choice, not a keyword to sprinkle on bindings. It activates when the compiler reports borrow conflicts or when you are weighing interior mutability against clearer data structures. The skill pushes you to ask whether mutation is essential, which actor should own changes, and whether work happens on one thread or many—then maps answers to &mut T, Cell, RefCell, Mutex, RwLock, or atomics. It explicitly discourages reflexive “add mut” or scope-splitting without revisiting structure. Although marked user-invocable false, agents should attach it when Rust error codes or messages mention mutable borrows and duplicate loans. Best paired with broader ownership skills in the same rust-skills family when errors chain across modules.730installs12M12 Lifecyclem12-lifecycle is a Rust design-choice skill from a layered skills curriculum. It answers when a resource should be created, used, and torn down, and which pattern fits: automatic cleanup via Drop, deferred creation with OnceLock or lazy crates, reuse through connection pools, scoped guards, or custom Drop-backed transaction boundaries. Solo builders shipping APIs, CLIs, or agent backends in Rust use it to avoid leaks, double-frees, and panic-skipping cleanup on error paths. The skill frames cost, ownership scope, and failure behavior before you write structs and traits, aligning with RAII mental models and common ecosystem crates. It is intentionally not a generic debugging or DevOps guide—it is procedural knowledge for backend Rust architecture at implementation time.727installs13M14 Mental ModelM14 Mental Model is a Rust-focused agent skill that teaches how to think in ownership, borrowing, and lifetimes instead of pointer-centric habits from Java, C#, or C++. Solo builders use it whenever Rust code feels like a fight with the borrow checker—before sketching APIs, during refactors, or while reviewing a teammate’s PR—because the skill frames each rule as resource responsibility rather than arbitrary compiler nagging. It walks through owning values that drop at scope end, lending references that must not outlive owners, and lifetime parameters that tie returned references to valid inputs. The content is conceptual but immediately applicable: you can invoke it at the start of a Build task, mid-Ship review when unsafe-looking references appear, or during Operate iteration when production bugs smell like stale borrows. It does not replace the Rust book; it gives your coding agent a shared vocabulary so generated code aligns with how Rust actually manages memory.713installs14M09 Domainm09-domain is a Rust-focused agent skill from the rust-skills playbook that walks solo builders through domain-driven design before writing structs and traits. It answers whether a concept is an entity or value object, which invariants must hold, and where aggregate boundaries sit, then ties each choice to idiomatic Rust—owned entities with IDs, Copy/Clone value objects, aggregate roots owning children, repository traits, and event enums. The skill is aimed at indie developers shipping APIs, CLIs, or small SaaS backends who want correctness and clear ownership trees instead of anemic models. Use it when triggers mention domain model, DDD, repository pattern, validation, or invariants, especially alongside other rust-skills layers. It is not a code generator; it is procedural guidance that reduces rework when persistence and HTTP layers are added later.711installs15M11 Ecosystemm11-ecosystem is a Rust-focused agent skill from a layered rust-skills curriculum (Layer 2: Design Choices). It helps solo builders answer the recurring question of which crate fits a job and how to integrate it without accumulating unmaintained dependencies. The skill walks through standard stack choices—serialization with serde, async with tokio, HTTP with reqwest or axum, data access with sqlx or diesel, CLI with clap, and errors with anyhow versus thiserror—while prompting judgment on maintenance, breaking changes, and feature flags. It also branches into ecosystem edges: Python bindings with PyO3, WebAssembly, and C interop via bindgen or cbindgen. The embedded Cargo.toml grep gives the agent immediate context about what is already in the project. Use it during implementation when dependency errors appear or when designing a new module that should align with community defaults rather than reinventing wheels.710installs16M13 Domain Errorm13-domain-error is a Rust-focused agent skill from the rust-skills stack that walks you through domain error strategy before you commit to types and propagation. It centers on one question—who handles the error and how should they recover—and forces categorization across end users, developers, SRE, automation, and irreversible failures. Solo builders shipping APIs or CLIs in Rust use it when ad-hoc `anyhow` strings would leak internals or omit retry policy. The document is concise Layer 2 design material rather than a codegen tool: it expects you to align messages, codes, monitoring hooks, and backoff rules with the error’s audience. It is not user-invocable directly in chat in all setups, but agents should pull it when designing or refactoring error modules in backend crates.697installs17Rust Trait ExplorerRust Trait Explorer is a focused agent skill for solo builders maintaining Rust backends who get lost in generic bounds and impl blocks spread across a workspace. Trigger it with /rust-trait-explorer plus a trait or struct name—or natural language like who implements Handler—and the agent follows a short LSP-first workflow: locate the symbol, jump to implementations, enrich each site with document symbols, and summarize an implementation map you can paste into a design note or refactor plan. It fits indie teams without a dedicated IDE plugin beyond what Claude Code or Cursor already exposes through LSP. You should reach for it during active Build work when onboarding to a foreign crate, auditing polymorphic handler traits, or verifying that a new type actually satisfies the traits your async stack expects. It is intentionally not a code generator; it accelerates navigation and mental models so you ship fewer mistaken dyn casts and orphan-rule surprises. Intermediate complexity assumes you already run rust-analyzer and know what traits and impl for mean; beginners still benefit once they have a project open in an LSP-capable editor.694installs18Rust Code NavigatorRust Code Navigator is an agent skill that wraps Language Server Protocol operations so solo builders can explore unfamiliar Rust codebases the way an IDE does. You invoke it when you need the definition of a struct or function, every place a symbol is used, or quick type and documentation from hover—without manually grepping across modules. It is built for agents that already have LSP, Read, and Glob in the toolchain, and it accepts an optional file and line anchor when the symbol is ambiguous. The workflow mirrors Ctrl+click navigation: resolve the symbol, run the right LSP operation, and return actionable locations for the next edit or review step. It does not scaffold projects or run builds; it shortens the loop between “what is this?” and “where do I change it?” during backend and systems work.679installs19Unsafe CheckerUnsafe Checker is an agent skill that encodes a structured audit playbook for Rust unsafe code, drawn from auto-generated rules in the rust-skills package. Solo builders shipping performance-critical CLI tools, systems APIs, or agent-native Rust extensions use it when the compiler’s safe boundary is not enough and human review must catch invariant violations. Invoke it while implementing unsafe in Build and again in Ship before merging, so agents flag abuse of unsafe for performance, missing SAFETY proofs, thread-shared raw pointers, and wrong mutable returns from immutable parameters. The rule tables separate paramount (P) from general (G) expectations, covering Auto trait manual impls, assert versus debug_assert in unsafe functions, and safe/unsafe API pairing for performance. It reduces production incidents and review churn by giving Cursor, Claude Code, and Codex the same checklist senior Rust reviewers use.678installs20Domain Clidomain-cli is a Layer 3 Rust domain skill for solo builders shipping command-line tools with Claude Code, Cursor, or Codex. It encodes non-negotiable CLI ergonomics—pipe-friendly stdout, actionable stderr, layered configuration, and correct exit codes—so agents do not reinvent bash-hostile binaries. The skill ties each domain rule to concrete Rust choices such as clap derive macros, Result-returning main, and figment-style config loading. It is scoped via Cargo.toml globs and is meant to complement broader Rust architecture skills rather than replace them. Invoke it whenever you are designing subcommands, progress output, shell completion, or TUI stacks (ratatui/crossterm) and want guardrails that keep scripts and CI wrappers reliable. The outcome is a CLI that behaves predictably in pipes, overrides, and automation.669installs21Rust Symbol AnalyzerRust Symbol Analyzer is an agent skill for solo and indie builders maintaining Rust libraries, CLIs, or services who need a fast, accurate picture of what exists before renaming types, splitting modules, or delegating edits to Claude Code, Cursor, or Codex. It drives the agent through Glob for Rust sources, Read where needed, and LSP documentSymbol and workspaceSymbol so you get hierarchical per-file symbols and project-wide matches instead of brittle text grep. You can scope to one file, filter to structs, traits, functions, or modules, or run a full-project pass that categorizes symbols and summarizes layout. It fits the Build phase when onboarding to an unfamiliar repo, planning refactors, or answering “what traits and structs do we have?” without manually opening every module tree.665installs22Rust Call Graphrust-call-graph is a Rust-focused agent skill that visualizes function relationships through the language server’s call hierarchy instead of guesswork from text search. Indie builders maintaining APIs, CLIs, or systems code use it when a change might ripple through callers—before extracting a helper, renaming a handler, or tracing an error path. You point at a function name (optional depth and direction), the agent resolves the symbol, runs prepareCallHierarchy, and pulls incoming and outgoing edges. Direction flags isolate “who calls this?” versus “what does this call?” for faster mental models than raw ripgrep. It assumes a working Rust LSP in the editor agent environment and read access to the crate tree. The output is an explorable call graph narrative suitable for planning a safe patch or documenting critical paths in a PR.661installs23Rust RouterRust Router is a meta agent skill that must run before your agent improvises Rust answers. It interprets intent—compile errors, ownership puzzles, async runtime comparisons, domain-specific fintech or CLI constraints—and maps the question through a layered framework (why the rules exist, which pattern fits, which submodule to invoke) rather than dumping a one-shot fix. For solo builders shipping CLIs, APIs, or performance-sensitive services, that routing cuts hallucinated APIs and wrong async guidance. The skill declares broad triggers: cargo, rustc, crate, tokio versus async-std debates, Send/Sync, and common error codes, plus glob hooks on Cargo.toml and Rust sources so Cursor-like agents attach it in real repos. Treat it as multi-phase: primary use is Build backend implementation, but the same router pays off in Ship when tests fail with borrow checker errors or type mismatches. It does not replace reading The Book; it orchestrates the rust-skills collection so each question hits the right deep skill. Version 2.0 keeps the root SKILL.md lean and pushes examples to sub-files.655installs24Rust LearnerRust-learner is a journey-wide research skill for solo builders working in Rust who need authoritative answers about compiler versions, crates.io packages, docs.rs APIs, edition choices, and Clippy lints. It detects whether specialized agent markdown files are available and routes queries accordingly—crate versions, changelog features, standard library documentation, third-party crate docs, or lint catalogs—so you are not guessing from stale training data. Keywords cover English and Chinese phrasing for version and dependency questions, making it useful during planning spikes, dependency upgrades, and mid-debug investigations. The skill allows Task, Read, Glob, Bash, and actionbook MCP tools when agents are present. Treat it as the primary fetch layer before you commit to a crate version or edition in Cargo.toml, especially when you need docs.rs or releases.rs grounded responses.654installs25Rust Deps Visualizerrust-deps-visualizer is a focused Rust agent skill that turns your crate graph into readable ASCII art for terminal or chat review. It is invoked when you want a quick picture of what pulls in tokio, serde, or other transitive deps without opening a GUI graph tool. The workflow parses Cargo.toml context, calls cargo metadata for direct dependency JSON, then cargo tree for the full hierarchy, honoring --depth N and an optional --features mode that annotates enabled feature sets on each line. Output conventions mirror standard tree diagrams, including category hints in enhanced examples. Allowed tools are Bash, Read, and Glob, matching a local repo workflow. Indie builders maintaining Rust CLIs or APIs use it to spot bloat, debug feature unification issues, or explain dependency choices in docs or PRs.647installs26Rust Skill CreatorRust Skill Creator is an agent skill that turns official Rust documentation into installable agent skills. When you ask to create a skill for tokio, serde, axum, or a std trait like Send, it identifies the correct docs.rs or std URL, then follows a two-mode workflow: full plugin mode chains LLM-oriented doc extraction into skill generation commands, while standalone mode still guides you through manual steps. Solo builders shipping Rust CLIs or backends with Claude Code, Cursor, or Codex use it to give agents grounded, repeatable crate knowledge instead of vague recall. It fits the Build phase while you extend your agent stack and document integrations. The skill is meta—about authoring skills—not about writing production Rust for you, so pair it with your normal implementation workflow after the skill file exists.631installs27Domain WebDomain Web is a Layer 3 constraint skill in the rust-skills stack for solo builders shipping HTTP services in Rust. It translates product realities—stateless requests, many concurrent connections, latency SLAs, security validation, and request tracing—into concrete Rust choices: async-by-default handlers, Arc-backed shared state, type-safe extractors, and tower middleware. Whether you are on axum, actix, warp, rocket, hyper, or reqwest-shaped clients, the skill keeps you from blocking the runtime, leaking request-scoped resources, or sharing mutable state unsafely across threads. It is not a step-by-step tutorial; it is the decision lens you invoke when Cargo.toml-backed web crates are in play, then trace down to deeper modules such as concurrency guidance. Pair it with framework-specific skills when you need handler boilerplate; use this when architecture and invariants must stay consistent across an API surface.615installs28Meta Cognition ParallelMeta Cognition Parallel is an experimental agent skill that coordinates three analyzers—language mechanics, design choices, and domain constraints—then synthesizes their outputs into one architectural recommendation for Rust questions. It targets solo builders and small teams using Claude Code or similar agents who hit subtle ownership, API shape, or domain-rule conflicts that sequential chat misses. Invoke it with /meta-parallel and your Rust question when you are exploring crate boundaries, error handling strategy, or concurrency models and want layered reasoning rather than a single-pass guess. The flow supports parallel agent mode or inline sequential execution before cross-layer synthesis in the main context. Status is explicitly experimental, so treat outputs as structured input to your own review, not as shipped guidance. It matters when Rust mistakes are expensive to unwind and you need explicit tradeoffs across language rules, design patterns, and problem-domain limits.602installs29Rust DailyRust Daily is an agent skill for solo Rust builders who want a repeatable digest of community and official news instead of manually checking Reddit, This Week in Rust, blog.rust-lang.org, Inside Rust, and Rust Foundation channels. It accepts a time range and optional category filter, then either loads a bundled rust-daily-reporter subagent or runs inline fetches (including browser automation for Reddit) when only the skill package is installed. The skill is intentionally trigger-driven—use it whenever Rust ecosystem movement might affect your crate choices, MSRV, or tooling—not only on Mondays. Multi-phase placement keeps it on Idea discover as the default shelf while remaining useful during Build when evaluating dependencies and Operate when tracking releases and incidents. Productivity & Planning captures the reporting workflow; permissions may include network, shell, and browser depending on execution mode.601installs30Domain Embeddeddomain-embedded is a Layer 3 domain constraint skill for no_std and microcontroller Rust. It is aimed at solo and indie builders who are writing firmware on ARM, RISC-V, ESP32, STM32, or nRF targets and need the agent to respect heapless memory, predictable timing, and interrupt-safe access patterns. Invoke it when Cargo.toml or .cargo/config.toml indicate an embedded workspace and you want HAL ownership, peripheral usage, and ISR code reviewed against embedded-hal norms rather than desktop Rust habits. The skill contrasts desktop patterns (dynamic allocation, std I/O) with stack-only structures like heapless::Vec and arrays, and flags blocking work inside ISRs. It does not replace board-specific HAL docs but keeps agent suggestions aligned with bare-metal reality so you ship deterministic firmware faster.581installs31Domain Cloud Nativedomain-cloud-native is a Layer 3 domain constraint skill for Rust builders shipping microservices on Kubernetes and Docker. It translates cloud-native rules—stateless processes, config from environment variables, liveness and readiness probes, horizontal scaling, and full request traceability—into concrete Rust implications such as tokio graceful shutdown, tracing with OpenTelemetry, and avoiding in-pod persistent state. Solo and indie builders use it when scaffolding gRPC/tonic services, hardening APIs before production, or aligning an agent-generated service sketch with real cluster behavior. It pairs naturally with broader Rust skills in the same repo for lifecycle and observability depth. The skill is reference-oriented rather than a one-shot generator: you invoke it while designing or reviewing architecture so agents do not silently introduce local state, missing health endpoints, or untraced request paths that break production debugging.557installs32Domain Fintechdomain-fintech is a Layer 3 domain-constraints skill for solo and indie builders shipping fintech in Rust. It translates regulatory and accounting realities—immutable audit trails, no floating-point money, bounded transactions, structured logging, and deterministic execution—into concrete Rust implications such as rust_decimal, Arc for shared immutable data, clear ownership at transaction boundaries, and value-object modeling. Use it when you are scaffolding payments, exchanges, ledgers, or any system where rounding errors or mutable history would break trust or compliance. The skill is reference-oriented rather than a one-shot generator: it steers architectural decisions before you commit types and persistence. It pairs naturally with broader Rust skills in the same collection for ownership and type-driven design, and it remains relevant when you later harden shipping and operate on production money flows.543installs33Domain Mldomain-ml is a Layer 3 domain guide for machine learning and AI workloads written in Rust. Solo builders and small teams use it when they need inference, embedding services, or data-heavy numeric pipelines without repeating Python-only playbooks. The skill translates ML realities—large tensors, GPU kernel overhead, float precision, and batch throughput—into concrete Rust implications such as zero-copy views, batched inference, lazy evaluation, and ONNX portability so models trained elsewhere can run in production binaries. It is especially valuable when memory bandwidth or GPU utilization is the bottleneck and when you want deterministic, versioned behavior for reproducible predictions. Invoke it while designing crates, choosing between candle versus tch-rs versus tract, or reviewing an architecture before you commit to copying gigabyte-scale arrays on every request.537installs34Domain Iotdomain-iot is a Rust-oriented domain constraint skill for Internet of Things work: sensors, MQTT, gateways, edge telemetry, actuators, and smart-home style deployments. It translates field realities—unreliable wireless, battery budgets, small footprints, physical tamper risk, and mandatory over-the-air updates—into design pressures your agent should not hand-wave away. The body organizes rules in a constraint-to-implication table and drills into network backoff with local buffering, power-efficient algorithms and sleep modes, encrypted transport, watchdog-style recovery, and rollback-safe upgrades. It explicitly points implementers toward companion modules for lifecycle buffering, structured retries, embedded no_std patterns, and performance discipline rather than inventing a monolithic framework. Solo and indie builders shipping device-adjacent Rust services or firmware-adjacent backends use it when MQTT, telemetry, or edge compute show up in the spec so architecture matches how devices actually fail in the wild.535installs