actionbook/rust-skills
38 skills49.3k installs50.7k starsGitHub
Install
npx skills add https://github.com/actionbook/rust-skillsSkills in this repo
1Coding Guidelinescoding-guidelines is an agent skill from actionbook/rust-skills that use when asking about rust code style or best practices. keywords: naming, formatting, comment, clippy, rustfmt, lint, code style, best practice, p.nam, g.fmt, code review, naming convention, variable. # Rust Coding Guidelines (50 Core Rules) ## Naming (Rust-Specific) | Rule | Guideline | |------|-----------| | No `get_` prefix | `fn name()` not `fn get_name()` | | Iterator convention | `iter()` / `iter_mut()` / `into_iter()` | | Conversion naming | `as_` (cheap &), `to_` (expensive), `into_` (ownership) | | Static var prefix | `G_CONFIG` for ` Developers invoke coding-guidelines during operate/infra work for cloud & infrastructure tasks. The skill documents triggers, prerequisites, and step-by-step workflows grounded in SKILL.md. Compatible with Claude Code, Cursor, and Codex agent runtimes that load marketplace skills. Review the Security Audits panel on this listing before installing in production environments.1.5kinstalls2M10 PerformanceThe m10-performance skill guides Rust performance optimization with a measure-first mindset using flamegraphs, perf, and criterion benchmarks to find real bottlenecks. It maps goals to design choices such as pre-allocation with with_capacity, contiguous Vec layouts, rayon parallelism, zero-copy Cow references, and smallvec for inline data. The skill asks whether optimization is worth added complexity and prioritizes algorithmic wins over cache or allocation tweaks. Thinking prompts cover measurement, priority ordering from algorithm through cache effects, and tradeoffs between memory, CPU, latency, and throughput. It traces decisions up to domain constraints and down to concrete Rust patterns. Triggers include performance, benchmark, profiling, flamegraph, criterion, SIMD, and allocation keywords. Use when developers profile Rust code and choose optimization strategies grounded in measurement.1.5kinstalls3M07 Concurrencym07-concurrency is an agent skill from actionbook/rust-skills that critical: use for concurrency/async. triggers: e0277 send sync, cannot be sent between threads, thread, spawn, channel, mpsc, mutex, rwlock, atomic, async, await, future, tokio, deadlock, race conditi. # Concurrency > **Layer 1: Language Mechanics** ## Core Question **Is this CPU-bound or I/O-bound, and what's the sharing model?** Before choosing concurrency primitives: - What's the workload type? - What data needs to be shared? - What's the thread safety requirement? --- ## Error → Design Question | Error | Don't Just Say | Ask Instead | Developers invoke m07-concurrency during operate/infra work for cloud & infrastructure tasks. The skill documents triggers, prerequisites, and step-by-step workflows grounded in SKILL.md. Compatible with Claude Code, Cursor, and Codex agent runtimes that load marketplace skills.1.5kinstalls4M06 Error HandlingThe m06-error-handling skill guides Rust error handling design choices mapping goals to Result and Option propagation, custom error types, anyhow and thiserror usage, and when panic is acceptable versus returning errors. It triggers on Result, unwrap, expect, error propagation, and custom error keywords with user-invocable false for automatic routing. Use when developers decide error types, propagation with the question mark operator, and panic boundaries in Rust services and libraries.1.5kinstalls5M02 ResourceThe m02-resource skill guides Rust smart pointer and resource management decisions across Box, Rc, Arc, Weak, RefCell, and Cell for heap allocation and shared ownership. Core question asks what ownership pattern the resource needs: single versus shared, single-thread versus multi-thread, and potential cycles requiring Weak. Error-to-design mapping converts heap allocation needs, Rc leaks, RefCell panics, and Arc overhead complaints into design questions rather than blind fixes. Trace up links Rc versus Arc confusion to m07-concurrency and memory leaks to m12-lifecycle. Trace down maps single-owner heap data to Box, shared immutable single-thread to Rc, shared multi-thread to Arc, and interior mutability to RefCell or Cell. Use when choosing smart pointers, reference counting, or RAII Drop patterns in Rust.1.5kinstalls6M04 Zero CostThe m04-zero-cost skill guides Rust generics, traits, and zero-cost abstraction decisions including errors E0277 E0308 E0599 E0038. Core question asks whether compile-time or runtime polymorphism is needed based on type knowledge at compile time, heterogeneous collections, and performance priority. Error mapping converts trait bound failures and object safety issues into abstraction level questions not blind bound additions. Thinking prompts choose trait versus enum versus concrete types and static impl Trait generics versus dynamic dyn Trait dispatch. Trace up links complex bounds to m09-domain and object safety to m05-type-driven. Use for generic, trait, impl, dyn, where, monomorphization, and trait bound not satisfied errors.1.5kinstalls7M05 Type DrivenThe m05-type-driven skill is designed for apply type-driven design with PhantomData, newtypes, and compile-time state validation in Rust. Type-Driven Design > Layer 1: Language Mechanics Core Question How can the type system prevent invalid states? Before reaching for runtime checks: Can the compiler catch this error? Invoke when the user asks about type state, PhantomData, newtype, sealed traits, or builder patterns.1.5kinstalls8M03 MutabilityThe m03-mutability skill is designed for resolve Rust borrow checker mutability errors with Cell, RefCell, Mutex, and interior mutability. Mutability > Layer 1: Language Mechanics Core Question Why does this data need to change, and who can change it? Before adding interior mutability, understand: Is mutation essential or accidental complexity? Invoke when the user hits cannot borrow as mutable, already borrowed, or interior mutability questions.1.5kinstalls9M01 OwnershipThe m01-ownership skill addresses Rust ownership, borrow, and lifetime issues including errors E0382 E0597 E0506 E0507 E0515 E0716 E0106 with design-first questioning instead of reflexive clones. Core question asks who should own data and for how long considering shared versus exclusive, short-lived versus long-lived, and transformed versus read-only roles. Error tables map each compiler error to design questions like who should own versus extend lifetime. Thinking prompts distinguish entity value object and temporary data roles and intentional versus accidental ownership. Trace up escalates repeated E0382 to m02-resource Arc Rc and E0597 to m09-domain scope boundaries. Use for ownership, borrow, lifetime, move, and clone decisions in Rust.1.5kinstalls10M09 DomainThe m09-domain skill is designed for model domain logic in Rust with entities, value objects, and bounded context patterns. Domain Modeling > Layer 2: Design Choices Core Question What is this concept's role in the domain? Before modeling in code, understand: Is it an Entity (identity matters) or Value Object (interchangeable)? Invoke when the user designs domain entities, value objects, or bounded contexts in Rust.1.4kinstalls11M15 Anti Patternm15-anti-pattern is a Rust anti-pattern reference skill that walks an agent through common ownership, error-handling, and performance mistakes with side-by-side bad and corrected examples. The skill covers patterns such as cloning to satisfy the borrow checker, boxing values unnecessarily, and other review-time smells called out in the actionbook/rust-skills repository. Developers reach for m15-anti-pattern when Rust compiles but feels slower than expected, when clones proliferate in hot paths, or when a PR needs structured guidance before human review. The excerpts document multiple named anti-patterns with runnable Rust snippets, making the output actionable during ship-phase review rather than generic style advice.1.4kinstalls12M14 Mental ModelThe m14-mental-model skill is designed for explain Rust ownership, borrow checker, and memory layout with mental models and analogies. Mental Models > Layer 2: Design Choices Core Question What's the right way to think about this Rust concept? When learning or explaining Rust: What's the correct mental model? Invoke when the user asks how to think about ownership, borrow checker, or Rust misconceptions.1.4kinstalls13M12 LifecycleThe m12-lifecycle skill is designed for design Rust resource lifecycles with RAII, Drop, pools, and lazy initialization. Resource Lifecycle > Layer 2: Design Choices Core Question When should this resource be created, used, and cleaned up? Before implementing lifecycle: What's the resource's scope? Invoke when the user designs RAII, Drop, connection pools, or lazy resource initialization in Rust.1.4kinstalls14M13 Domain ErrorThe m13-domain-error skill is designed for use when designing domain error handling. Keywords: domain error, error categorization, recovery strategy, retry, fallback, domain error hierarchy, user-facing vs internal. Domain Error Strategy > Layer 2: Design Choices Core Question Who needs to handle this error, and how should they recover? Before designing error types: Is this user-facing or internal? Invoke when the user designing domain error handling.1.4kinstalls15M11 EcosystemThe m11-ecosystem skill is designed for use when integrating crates or ecosystem questions. Keywords: E0425, E0433, E0603, crate, cargo, dependency, feature flag, workspace, which crate to use, using external C. Before adding dependencies: Is there a standard solution? --- Trace Up ↑ To domain constraints (Layer 3): | Question | Trace To | Ask | |----------|----------|-----| | Framework choice | domain-* | What constraints matter? Invoke when the user integrating crates or ecosystem questions.1.4kinstalls16Unsafe CheckerThe unsafe-checker skill is designed for cRITICAL: Use for unsafe Rust code review and FFI. Triggers on: unsafe, raw pointer, FFI, extern, transmute, *mut, *const, union, #[repr(C)], libc, std::ffi, MaybeUninit,. Invoke when the user asks about unsafe checker or related SKILL.md workflows.1.4kinstalls17Rust Code NavigatorThe rust-code-navigator skill is designed for navigate Rust code using LSP. Triggers on: /navigate, go to definition, find references, where is defined, 跳转定义, 查找引用, 定义在哪, 谁用了这个. Rust Code Navigator Navigate large Rust codebases efficiently using Language Server Protocol. Usage Examples: /rust-code-navigator parse_config - Find definition of parse_config /rust-code-navigator MyStruct in src/lib.rs:42 - Navigate from specific location LSP Operations 1. Invoke when the user asks about rust code navigator or related SKILL.md workflows.1.4kinstalls18Rust Refactor HelperThe rust-refactor-helper skill is designed for safe Rust refactoring with LSP analysis. Triggers on: /refactor, rename symbol, move function, extract, 重构, 重命名, 提取函数, 安全重构. Rust Refactor Helper Perform safe refactoring with comprehensive impact analysis. Related Skills | When | See | |------|-----| | Navigate to symbol | rust-code-navigator | | Understand call flow | rust-call-graph | | Project structure | rust-symbol-analyzer | | Trait implementations | rust-trait-explorer | Invoke when the user asks about rust refactor helper or related SKILL.md workflows.1.4kinstalls19Rust Call GraphThe rust-call-graph skill is designed for visualize Rust function call graphs using LSP. Triggers on: /call-graph, call hierarchy, who calls, what calls, 调用图, 调用关系, 谁调用了, 调用了谁. Rust Call Graph Visualize function call relationships using LSP call hierarchy. Prepare Call Hierarchy Get the call hierarchy item for a function. Invoke when the user asks about rust call graph or related SKILL.md workflows.1.4kinstalls20Rust Trait ExplorerThe rust-trait-explorer skill is designed for explore Rust trait implementations using LSP. Triggers on: /trait-impl, find implementations, who implements, trait 实现, 谁实现了, 实现了哪些trait. Rust Trait Explorer Discover trait implementations and understand polymorphic designs. Usage Examples: /rust-trait-explorer Handler - Find all implementors of Handler trait /rust-trait-explorer MyStruct - Find all traits implemented by MyStruct LSP Operations Go to Implementation Find all implementations of a trait. Invoke when the user asks about rust trait explorer or related SKILL.md workflows.1.4kinstalls21Domain CliThe domain-cli skill is designed for use when building CLI tools. Keywords: CLI, command line, terminal, clap, structopt, argument parsing, subcommand, interactive, TUI, ratatui, crossterm, indicatif, progress. Invoke when the user building CLI tools.1.4kinstalls22Rust Symbol AnalyzerThe rust-symbol-analyzer skill is designed for analyze Rust project structure using LSP symbols. Triggers on: /symbols, project structure, list structs, list traits, list functions, 符号分析, 项目结构, 列出所有, 有哪些struct. Rust Symbol Analyzer Analyze project structure by examining symbols across your Rust codebase. Usage Examples: /rust-symbol-analyzer - Analyze entire project /rust-symbol-analyzer src/lib.rs - Analyze single file /rust-symbol-analyzer --type trait - List all traits in project LSP Operations 1. Invoke when the user asks about rust symbol analyzer or related SKILL.md workflows.1.4kinstalls23Domain WebThe domain-web skill is Layer 3 domain constraints for Rust web services covering HTTP, REST, GraphQL, WebSocket, and middleware design. Critical rules require non-blocking async handlers, thread-safe shared state via Arc and Arc<RwLock<T>>, and request-scoped resource lifetimes through extractors. Framework comparison maps axum for modern tower-based APIs, actix-web for performance, warp for composable filters, and rocket for rapid macro-driven development. Key crates include axum, reqwest, serde_json, jsonwebtoken, tower-sessions, sqlx, and tower middleware layers. Design patterns document extractors like State and Json, unified AppError IntoResponse mapping, tower middleware stacks, and Arc AppState for configuration. Axum handler example shows State db pool with Json payload and structured error responses. Common mistakes warn against blocking handlers, Rc in shared state, missing validation, and absent error responses. Trace-down tables link concurrency, type-driven validation, and lifecycle patterns to related rust-skills modules for deeper implementation guidance.1.4kinstalls24Rust LearnerThe rust-learner skill fetches Rust and crate information including latest versions, docs.rs API documentation, releases.rs changelog features, and crates.io metadata. Agent mode detects researcher files at ../../agents/ for crate-researcher, rust-changelog, std-docs-researcher, docs-researcher, and clippy-researcher then launches background Tasks. Inline mode uses actionbook MCP tools and Bash when agent files are absent. Routing table maps query types: Rust version features to rust-changelog from releases.rs, crate versions to crate-researcher from lib.rs and crates.io, std library docs like Send and Sync to std-docs-researcher from doc.rust-lang.org, third-party crate docs to docs-researcher from docs.rs, and Clippy lints to clippy-researcher. Primary skill for fetching Rust and crate information with keywords covering latest version, changelog, edition 2024, cargo add, and Chinese version queries. Version 2.1.0 supports both plugin install with agents and standalone inline execution. Helps users pick crate versions, read API surfaces, and understand new Rust stable features without guessing from training data cutoff.1.3kinstalls25Meta Cognition ParallelThe meta-cognition-parallel skill is an experimental three-layer parallel analysis coordinator for Rust questions triggered by /meta-parallel or parallel analysis keywords. Instead of sequential review, it launches Layer 1 language mechanics, Layer 2 design choices, and Layer 3 domain constraints analyzers then synthesizes cross-layer results into an architectural solution. Agent mode detects layer analyzer files at ../../agents/layer1-analyzer.md through layer3-analyzer.md and launches three general-purpose Tasks in a single message with run_in_background true for true parallelism. Inline mode falls back when agent files are missing, running layers sequentially in the main context. Step one parses user query, code snippets, and domain hints like trading, web, or embedded. Cross-layer synthesis happens in the main context with all layer results before recommending fixes. Example trigger handles E0382 move errors in trading systems. Experimental status version 0.2.0 warns that behavior may change. Contrasts with sequential meta-cognition skills by maximizing throughput on complex Rust debugging questions requiring multiple cognitive perspectives simultaneously.1.3kinstalls26Rust Skill CreatorThe rust-skill-creator skill use when creating skills for Rust crates or std library documentation Keywords create rust skill create crate skill create std skill 创建 rust skill 创建 crate skill 创建 std skill 动态 rust skill 动态 crate skill skill for tokio skill for serde skill for axum generate rust skill rust 技能 crate 技能 从文档创建skill from docs create skill Rust Skill Creator Version 2 1 0 Last Updated 2025-01-27 Create dynamic skills for Rust crates and std library documentation When to Use This skill handles requests to create skills for Third-party crates tokio serde axum etc Rust standard library std sync std marker etc Any Rust documentation URL Execution Mode Detection CRITICAL Check if related commands skills are available This skill relies on create-llms-for-skills command create-skills-via-llms command Agent Mode Plugin Install When the commands above are available full plugin installation Workflow 1 Identify the Target User Request Target Type URL Pattern create tokio skill Third-party crate docs rs tokio latest tokio create Send trait skill Std library doc rust-lang1.3kinstalls27Rust DailyThe rust-daily skill Rust Daily Report Version 2 1 0 Last Updated 2025-01-27 Fetch Rust community updates filtered by time range Data Sources Category Sources Ecosystem Reddit r rust This Week in Rust Official blog rust-lang org Inside Rust Foundation rustfoundation org news blog events Parameters time_range day week month default week category all ecosystem official foundation Execution Mode Detection CRITICAL Check agent file availability first to determine execution mode Try to read agents rust-daily-reporter md Agent Mode Plugin Install When agents rust-daily-reporter md exists Workflow 1 Read agents rust-daily-reporter md 2 Task subagent_type general-purpose run_in_background false prompt agent content 3 Format and present to user Inline Mode Skills-only Install When agent file is NOT available execute each source directly 1 Reddit r rust bash Using agent-browser CLI agent-browser open https www reddit com r rust hot agent-browser get text Post limit 10 agent-browser close Or with WebFetch fallback WebFetch https www reddit com r rust hot Extract top 10 posts with scores and titles Parse output into Score Title1.3kinstalls28Rust Deps VisualizerThe rust-deps-visualizer skill visualize Rust project dependencies as ASCII art Triggers on deps-viz dependency graph show dependencies visualize deps 依赖图 依赖可视化 显示依赖 Rust Dependencies Visualizer Generate ASCII art visualizations of your Rust project's dependency tree Usage rust-deps-visualizer depth N features Options depth N Limit tree depth default 3 features Show feature flags Output Format Simple Tree Default my-project v0 1 0 tokio v1 49 0 pin-project-lite v0 2 x bytes v1 x serde v1 0 x serde_derive v1 0 x anyhow v1 x Feature-Aware Tree my-project v0 1 0 tokio v1 49 0 rt rt-multi-thread macros fs io-util pin-project-lite v0 2 x bytes v1 x serde v1 0 x derive serde_derive v1 0 x proc-macro anyhow v1 x std Implementation Step 1 Parse Cargo toml for direct dependencies bash cargo metadata format-version 1 no-deps 2 dev null Step 2 Get full dependency tree bash cargo tree depth DEPTH 3 FEATURES features 2 dev null Step 3 Format as ASCII art tree Use these box-drawing characters for middle items for last1.3kinstalls29Domain Cloud NativeThe domain-cloud-native skill encodes Layer 3 domain constraints for Rust services targeting Kubernetes and container platforms. It maps 12-factor config, observability, health endpoints, graceful shutdown, horizontal scaling, and small binaries to concrete Rust patterns using tokio, tonic, tracing, opentelemetry, and kube crates. Critical rules forbid local persistent state, require SIGTERM handling with connection draining, and mandate traceable requests via tracing spans. Code patterns document axum health and readiness routes, graceful shutdown with ctrl_c, and external state through Redis or databases instead of static mut. Common mistakes table covers local file state, missing SIGTERM handling, absent tracing, and static configuration. The skill traces constraints down to related m07-concurrency, domain-web, and m12-lifecycle patterns for implementation guidance.1.2kinstalls30Domain MlThe domain-ml skill defines Layer 3 domain constraints for machine learning and AI applications in Rust. Rules map large data to zero-copy streaming, GPU acceleration to candle and tch-rs, model portability to ONNX, batch processing to throughput-focused inference, numerical precision to careful f32 and f64 handling, and reproducibility to seeded randomness and versioning. Critical constraints forbid copying large tensors unnecessarily, require batched GPU operations to amortize kernel launch overhead, and emphasize deterministic pipelines where reproducibility matters. Key crates include ndarray, candle, tch-rs, and burn with patterns tracing down to companion concurrency and lifecycle skills for async data loading and resource management in inference services.1.2kinstalls31Domain EmbeddedThe domain-embedded skill defines Layer 3 domain constraints for embedded and no_std Rust on microcontrollers and bare-metal targets. Rules forbid heap allocation, require interrupt-safe shared state with critical sections, and enforce HAL peripheral ownership to prevent conflicting hardware access. It maps constraints to heapless collections, Mutex patterns, and singleton peripherals across ARM, RISC-V, ESP32, STM32, and nRF platforms. Agents trace embedded decisions down to companion concurrency and lifecycle skills for firmware services. no_std and no-heap embedded Rust domain constraints. Interrupt-safe shared state with critical sections. HAL peripheral ownership and singleton patterns. heapless collections and static buffer sizing. Targets MCU, bare metal, and firmware HAL workflows. Apply embedded no_std Rust constraints for microcontrollers, HAL ownership, and interrupt safety.1.2kinstalls32Domain Fintechdomain-fintech is a Layer 3 domain skill in actionbook/rust-skills for fintech apps in Rust. It translates financial rules—immutable audit trails, no floating-point currency, transaction boundaries, compliance logging, and reproducibility—into concrete Rust design choices such as rust_decimal, Arc immutability, clear ownership, and structured tracing. Developers reach for domain-fintech when implementing money, transactions, exchange rates, ledgers, or accounting logic where precision and auditability matter. The skill is user-invocable false, meant for automatic application when fintech keywords appear in backend Rust work.1.2kinstalls33Domain Iotdomain-iot is an actionbook rust-skills Layer 3 domain module for Internet of Things, edge, sensor, and smart-home Rust development. It maps domain rules to design constraints: unreliable networks require offline-first local buffering, power limits demand sleep modes and minimal allocation, resource caps push no_std where feasible, and security mandates TLS plus signed firmware. The skill surfaces keywords including MQTT, telemetry, actuators, gateways, and edge computing so agents apply the right Rust patterns during implementation. Developers reach for domain-iot when writing device firmware services, telemetry collectors, or gateway backends where embedded constraints beat generic web-service defaults. It complements general Rust skills by anchoring architectural decisions to IoT realities instead of datacenter assumptions.1.2kinstalls34Rust Routerrust-router is an actionbook/rust-skills Claude Code skill marked as highest priority for all Rust work including errors, design, and coding comparisons. The skill triggers on cargo, rustc, Cargo.toml, async/await, tokio, Send, Sync, and common compiler errors such as E0382, E0597, E0277, E0308, E0499, E0502, and E0596 covering borrow, lifetime, ownership, trait, and type failures. Developers reach for rust-router when generic LLM answers miss Rust-specific reasoning about value moves, cannot borrow, or does not live long enough diagnostics. The framework supports intent analysis and best-practice comparisons such as tokio versus async-std before producing actionable guidance.855installs35Core Dynamic Skillscore-dynamic-skills is a skill from actionbook/rust-skills for implementing or extending Rust-based agent skills with dynamic loading, shared core patterns, and composable capability modules. It targets developers wiring CLI or API agents where capabilities should load at runtime instead of compiling every integration statically. The patterns emphasize reusable core crates, modular skill boundaries, and composition so new agent abilities can ship without rewriting the host runtime. Reach for core-dynamic-skills when scaffolding a Rust agent host, refactoring monolithic command handlers into plug-in skills, or aligning multiple agent integrations on one shared core. It assumes comfort with Rust modules, trait boundaries, and agent orchestration rather than one-off scripting.749installs36Core Fix Skill Docscore-fix-skill-docs version 2.1.0 from actionbook/rust-skills is an internal maintenance skill invoked via /fix-skill-docs to keep Rust crate skills accurate. It scans ~/.claude/skills/{crate} directories, parses Documentation sections for ./references/*.md links, reports OK versus MISSING files, and either launches background agents or uses inline agent-browser CLI and WebFetch against docs.rs to backfill missing modules. Flags include --check-only for reporting only and --remove-invalid to strip references that cannot be fetched. The skill disables automatic model invocation and expects explicit /fix-skill-docs calls. Reach for core-fix-skill-docs when dynamic Rust skills drift from docs.rs after crate updates and reference trees contain broken or absent markdown files.742installs37Core Actionbookcore-actionbook is an internal support skill in actionbook/rust-skills that connects agents to the actionbook MCP server for pre-computed browser action manuals. Instead of parsing entire HTML pages, agents call search_actions with a keyword and get_action_by_id to retrieve URL-based action IDs, content previews, CSS or XPath selectors, element types, and allowed methods such as click, type, and extract. The three-step workflow is search, fetch the manual, then execute selectors with a browser automation tool such as agent-browser. Parameters include hybrid vector or fulltext search, a default limit of five results, optional sourceIds filters, and minScore thresholds. The skill is user-invocable false and should load only when another rust-skills workflow explicitly requests actionbook-backed selectors. Developers reach for core-actionbook when rust-learner or related rust-skills agents need reliable docs.rs, crates.io, or release-page extraction during Rust research automation.738installs38Core Agent Browsercore-agent-browser is an internal support skill in actionbook/rust-skills marked user-invocable false and disable-model-invocation true. It orchestrates vercel-labs agent-browser CLI as the last-resort browser automation layer after rust-learner and actionbook MCP pre-computed selectors. Use core-agent-browser when actionbook lacks selectors for a target site, interactive browser testing is required, or screenshots and form filling are needed for Rust crate and documentation research. The skill defines a three-tier fetch priority: rust-learner orchestration, actionbook MCP structured manuals, then agent-browser CLI direct automation. Background agents need explicit permission to run agent-browser in project configuration. Developers indirectly benefit when rust-learner, docs-researcher, or crate-researcher skills escalate to live browser fetches for crates.io, docs.rs, or release pages missing from actionbook coverage.735installs