Rust Skill Creator
Generate dynamic agent skills from docs.rs or std library pages so Rust crate knowledge stays current in Claude-style workflows.
Overview
Rust Skill Creator is a journey-wide agent skill that builds docs-backed Rust crate and std-library skills for your agent—usable whenever you need accurate crate context before coding.
Install
npx skills add https://github.com/actionbook/rust-skills --skill rust-skill-creatorWhat is this skill?
- Targets third-party crates (tokio, serde, axum) and std modules via docs.rs / doc.rust-lang.org URL patterns
- Version 2.1.0 workflow with execution-mode detection for full plugin vs limited install
- Depends on /create-llms-for-skills and /create-skills-via-llms when Agent Mode commands are present
- argument-hint crate_name or std::module with context:fork and general-purpose agent
- Maps user phrases (create tokio skill, Send trait skill) to concrete documentation URLs
- Skill version 2.1.0 (last updated 2025-01-27 in SKILL frontmatter)
Adoption & trust: 821 installs on skills.sh; 1.2k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent lacks fresh, crate-specific procedural knowledge and you do not want to manually maintain SKILL.md files against moving docs.rs releases.
Who is it for?
Rust indie devs standardizing agent skills per dependency and std trait modules across projects.
Skip if: Non-Rust stacks, or users who only need a single inline code snippet without a maintained skill package.
When should I use this skill?
Use when creating skills for Rust crates or std library documentation (create rust skill, tokio/serde/axum, generate from docs URL).
What do I get? / Deliverables
You get a generated or orchestrated Rust skill tied to a crate or std module URL, ready to fork into agent sessions after plugin commands complete.
- SKILL.md package scoped to a crate or std module
- LLM-derived skill content sourced from docs.rs or doc.rust-lang.org
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Spin up an axum skill from docs to compare framework ergonomics before committing to your API stack.
Generate a tokio skill so implementation sessions inherit current async runtime APIs.
Add a serde skill after choosing JSON contracts for your CLI or SaaS API layer.
Regenerate a crate skill when docs.rs publishes a breaking minor and agent answers drift.
How it compares
Meta skill generator for Rust docs—not a runtime MCP server and not a substitute for reading unsafe or MSRV policy yourself.
Common Questions / FAQ
Who is rust-skill-creator for?
Solo builders and small teams using agentic IDEs who ship Rust and want repeatable, documentation-sourced skills per crate or std module.
When should I use rust-skill-creator?
At the start of a new crate integration in Build, when refreshing agent context after a major dependency upgrade in Operate, or during Validate when exploring whether a crate fits your design—any time you need a dedicated Rust skill from docs.
Is rust-skill-creator safe to install?
It may fork agents and call LLM generation commands against documentation URLs; review the Security Audits panel on this Prism page and vet network-using plugin commands in your environment.
SKILL.md
READMESKILL.md - Rust Skill Creator
# 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-lang.org/std/marker/trait.Send.html` | | "create skill from URL" + URL | Custom URL | User-provided URL | #### 2. Execute the Command Use the `/create-llms-for-skills` command: ``` /create-llms-for-skills <url> [requirements] ``` **Examples:** ```bash # For third-party crate /create-llms-for-skills https://docs.rs/tokio/latest/tokio/ # For std library /create-llms-for-skills https://doc.rust-lang.org/std/marker/trait.Send.html # With specific requirements /create-llms-for-skills https://docs.rs/axum/latest/axum/ "Focus on routing and extractors" ``` #### 3. Follow-up with Skill Creation After llms.txt is generated, use: ``` /create-skills-via-llms <crate_name> <llms_path> [version] ``` --- ## Inline Mode (Skills-only Install) **When the commands above are NOT available, create skills manually:** ### Step 1: Identify Target and Construct URL | Target | URL Template | |--------|--------------| | Crate overview | `https://docs.rs/{crate}/latest/{crate}/` | | Crate module | `https://docs.rs/{crate}/latest/{crate}/{module}/` | | Std trait | `https://doc.rust-lang.org/std/{module}/trait.{Name}.html` | | Std struct | `https://doc.rust-lang.org/std/{module}/struct.{Name}.html` | | Std module | `https://doc.rust-lang.org/std/{module}/index.html` | ### Step 2: Fetch Documentation ```bash # Using agent-browser CLI agent-browser open "<documentation_url>" agent-browser get text ".docblock" agent-browser close ``` **Or with WebFetch fallback:** ``` WebFetch("<documentation_url>", "Extract API documentation including types, functions, and examples") ``` ### Step 3: Create Skill Directory ```bash mkdir -p ~/.claude/skills/{crate_name} mkdir -p ~/.claude/skills/{crate_name}/references ``` ### Step 4: Generate SKILL.md Create `~/.claude/skills/{crate_name}/SKILL.md` with this template: ```markdown --- name: {crate_name} description: "Documentation for {crate_name} crate. Keywords: {keywords}" --- # {Crate Name} > **Version:** {version} | **Source:** docs.rs ## Overview {Brief description from documentation} ## Key Types ### {Type1} {Description and usage} ### {Type2} {Description and usage} ## Common Patterns {Usage patterns extracted from documentation} ## Examples ```rust {Example code from documentation} ``` ## Documentation - `./references/overview.md` - Main overview - `./references/{module}.md` - Module documentation ## Links - [docs.rs](https://docs.rs/{crate}) - [crates.io](https://crates.io/crates/{crate}) ``` ### Step 5: Generate Reference Files For each major module or type, create a reference file: ```bash # Fetch and save module documentation a