rust-skill-creator
actionbook/rust-skills
Create dynamic skills for Rust crates and standard library documentation.
What is rust-skill-creator?
This skill generates installable skills for Rust crates (tokio, serde, axum) and std library modules. Use it when you need to create reusable documentation-based skills that agents can reference for Rust API information.
- Identifies Rust crate and std library targets from user requests
- Constructs correct documentation URLs for docs.rs and doc.rust-lang.org
- Fetches and extracts API documentation, types, functions, and examples
- Generates SKILL.md files with structured documentation and reference materials
- Creates skill directory structures at ~/.claude/skills/{crate_name}/
- Supports both agent mode (via /create-llms-for-skills command) and inline mode (manual skill creation)
How to install rust-skill-creator
npx skills add https://github.com/actionbook/rust-skills --skill rust-skill-creator- agent-browser CLI tool (for fetching documentation) or WebFetch capability
- Write access to ~/.claude/skills/ directory
- For agent mode: /create-llms-for-skills and /create-skills-via-llms commands available
How to use rust-skill-creator
- 1.Identify the target: specify a crate name (tokio, serde) or std module (std::sync, std::marker)
- 2.If commands are available, run /create-llms-for-skills with the documentation URL
- 3.If using inline mode, construct the correct docs.rs or doc.rust-lang.org URL
- 4.Fetch the documentation using agent-browser or WebFetch
- 5.Create the skill directory structure under ~/.claude/skills/{crate_name}/
- 6.Generate SKILL.md with overview, key types, patterns, and examples
- 7.Create reference files in the references/ subdirectory for major modules
- 8.Verify the skill structure and content are complete
Use cases
- Create a reusable skill for tokio to help agents understand async runtime APIs
- Generate documentation skills for std library traits like Send and Sync
- Build skills for popular crates like serde, axum, or other third-party libraries
- Extract and organize API documentation into agent-readable skill format
- Create skills from custom documentation URLs provided by users
- Rust developers building agent skills
- Teams maintaining skill libraries for coding agents
- Developers who want to make Rust crate documentation accessible to AI agents
- Anyone creating reusable reference materials for Rust APIs
rust-skill-creator FAQ
Agent mode uses /create-llms-for-skills and /create-skills-via-llms commands when available for automated skill generation. Inline mode manually creates skills by fetching documentation and building SKILL.md files directly when those commands aren't available.
For third-party crates, use https://docs.rs/{crate}/latest/{crate}/. For std library items, use https://doc.rust-lang.org/std/{module}/ with the appropriate path (e.g., trait.Send.html for traits, struct.Vec.html for structs).
Yes, you can run the skill creation process multiple times for different crates. Each crate gets its own directory under ~/.claude/skills/ with separate SKILL.md and reference files.
Reference files should contain extracted API documentation for specific modules or types, including function signatures, trait implementations, usage patterns, and code examples from the official documentation.
Verify the crate exists on crates.io or the std module exists in the Rust documentation. Check that the URL follows the correct template and the crate/module name is spelled correctly.
Full instructions (SKILL.md)
Source of truth, from actionbook/rust-skills.
name: rust-skill-creator description: "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" argument-hint: "<crate_name|std::module>" context: fork agent: general-purpose
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-skillscommand/create-skills-via-llmscommand
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:
# 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
# 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
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:
---
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
### Step 5: Generate Reference Files
For each major module or type, create a reference file:
```bash
# Fetch and save module documentation
agent-browser open "https://docs.rs/{crate}/latest/{crate}/{module}/"
agent-browser get text ".docblock" > ~/.claude/skills/{crate_name}/references/{module}.md
agent-browser close
Step 6: Verify Skill
# Check skill structure
ls -la ~/.claude/skills/{crate_name}/
cat ~/.claude/skills/{crate_name}/SKILL.md
URL Construction Helper
| 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 |
Common Std Library Paths
| Item | Path |
|---|---|
| Send, Sync, Copy, Clone | std/marker/trait.{Name}.html |
| Arc, Mutex, RwLock | std/sync/struct.{Name}.html |
| Rc, Weak | std/rc/struct.{Name}.html |
| RefCell, Cell | std/cell/struct.{Name}.html |
| Box | std/boxed/struct.Box.html |
| Vec | std/vec/struct.Vec.html |
| String | std/string/struct.String.html |
| Option | std/option/enum.Option.html |
| Result | std/result/enum.Result.html |
Example Interactions
Example 1: Create Crate Skill (Agent Mode)
User: "Create a dynamic skill for tokio"
Claude:
1. Identify: Third-party crate "tokio"
2. Execute: /create-llms-for-skills https://docs.rs/tokio/latest/tokio/
3. Wait for llms.txt generation
4. Execute: /create-skills-via-llms tokio ~/tmp/{timestamp}-tokio-llms.txt
Example 2: Create Crate Skill (Inline Mode)
User: "Create a dynamic skill for tokio"
Claude:
1. Identify: Third-party crate "tokio"
2. Fetch: agent-browser open "https://docs.rs/tokio/latest/tokio/"
3. Extract documentation
4. Create: ~/.claude/skills/tokio/SKILL.md
5. Create: ~/.claude/skills/tokio/references/
6. Save reference files for key modules (sync, task, runtime, etc.)
Example 3: Create Std Library Skill
User: "Create a skill for Send and Sync traits"
Claude:
1. Identify: Std library traits
2. (Agent Mode) Execute: /create-llms-for-skills https://doc.rust-lang.org/std/marker/trait.Send.html https://doc.rust-lang.org/std/marker/trait.Sync.html
(Inline Mode) Fetch each URL, create skill manually
3. Complete skill creation
DO NOT
- Use
best-skill-creatorfor Rust-related skill creation - Guess documentation URLs without verification
- Skip documentation fetching step
Output Location
All generated skills are saved to: ~/.claude/skills/
Error Handling
| Error | Cause | Solution |
|---|---|---|
| Commands not found | Skills-only install | Use inline mode |
| URL not found | Invalid crate/module | Verify crate exists on crates.io |
| Empty documentation | API changed | Use alternative selectors |
| Permission denied | Directory issue | Check ~/.claude/skills/ permissions |
Related skills
More from actionbook/rust-skills and the wider catalog.

rust-symbol-analyzer
Analyze Rust project structure and list symbols (structs, traits, functions) using LSP.

rust-trait-explorer
Explore Rust trait implementations and polymorphic designs using LSP.

unsafe-checker
Detects and reviews unsafe Rust code patterns, FFI calls, and memory safety issues.

coding-guidelines
Reference for Rust code style, naming conventions, and best practices from 50 core rules.

esp32-firmware-engineer
ESP32 firmware engineering for ESP-IDF projects. Write, review, and debug embedded C/C++ code involving FreeRTOS tasks/queues/timers, GPIO/I2C/SPI/UART/ADC/PWM peripherals, TWAI/CAN, Wi-Fi/BLE networking, OTA updates, Secure Boot and flash encryption, LVGL display integration, build/flash/monitor workflows, logging, crash analysis, memory/code-size optimization, low-power sleep/wakeup design, on-device USB/serial service terminals, and board bring-up. Use when an agent is asked to implement ESP-IDF firmware features, review embedded changes for correctness or race conditions, investigate boot/runtime failures or Guru Meditation panics, interpret serial logs, fix build/link/flash problems, optimize RAM/flash usage, tune deep sleep/light sleep behavior, harden firmware for production, add a service console/CLI, integrate a display with LVGL, or diagnose hardware-software integration issues on ESP32-class devices.

api-and-interface-design
Design stable, hard-to-misuse APIs and interfaces with proven principles and patterns.