PluginBench
Skill
Review
Audit score 70

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
Prerequisites
  • 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
Claude Code
Cursor
Windsurf
Cline

How to use rust-skill-creator

  1. 1.Identify the target: specify a crate name (tokio, serde) or std module (std::sync, std::marker)
  2. 2.If commands are available, run /create-llms-for-skills with the documentation URL
  3. 3.If using inline mode, construct the correct docs.rs or doc.rust-lang.org URL
  4. 4.Fetch the documentation using agent-browser or WebFetch
  5. 5.Create the skill directory structure under ~/.claude/skills/{crate_name}/
  6. 6.Generate SKILL.md with overview, key types, patterns, and examples
  7. 7.Create reference files in the references/ subdirectory for major modules
  8. 8.Verify the skill structure and content are complete

Use cases

Good for
  • 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
Who it's for
  • 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

What's the difference between agent mode and inline mode?

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.

How do I find the correct documentation URL for a crate?

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).

Can I create skills for multiple crates at once?

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.

What should I include in the 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.

What if the documentation URL returns an error?

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-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 RequestTarget TypeURL Pattern
"create tokio skill"Third-party cratedocs.rs/tokio/latest/tokio/
"create Send trait skill"Std librarydoc.rust-lang.org/std/marker/trait.Send.html
"create skill from URL" + URLCustom URLUser-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

TargetURL Template
Crate overviewhttps://docs.rs/{crate}/latest/{crate}/
Crate modulehttps://docs.rs/{crate}/latest/{crate}/{module}/
Std traithttps://doc.rust-lang.org/std/{module}/trait.{Name}.html
Std structhttps://doc.rust-lang.org/std/{module}/struct.{Name}.html
Std modulehttps://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

TargetURL Template
Crate overviewhttps://docs.rs/{crate}/latest/{crate}/
Crate modulehttps://docs.rs/{crate}/latest/{crate}/{module}/
Std traithttps://doc.rust-lang.org/std/{module}/trait.{Name}.html
Std structhttps://doc.rust-lang.org/std/{module}/struct.{Name}.html
Std modulehttps://doc.rust-lang.org/std/{module}/index.html

Common Std Library Paths

ItemPath
Send, Sync, Copy, Clonestd/marker/trait.{Name}.html
Arc, Mutex, RwLockstd/sync/struct.{Name}.html
Rc, Weakstd/rc/struct.{Name}.html
RefCell, Cellstd/cell/struct.{Name}.html
Boxstd/boxed/struct.Box.html
Vecstd/vec/struct.Vec.html
Stringstd/string/struct.String.html
Optionstd/option/enum.Option.html
Resultstd/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-creator for 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

ErrorCauseSolution
Commands not foundSkills-only installUse inline mode
URL not foundInvalid crate/moduleVerify crate exists on crates.io
Empty documentationAPI changedUse alternative selectors
Permission deniedDirectory issueCheck ~/.claude/skills/ permissions

Related skills

More from actionbook/rust-skills and the wider catalog.

RUrust-symbol-analyzer logo

rust-symbol-analyzer

actionbook/rust-skills

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

2.8k installs
RUrust-trait-explorer logo

rust-trait-explorer

actionbook/rust-skills

Explore Rust trait implementations and polymorphic designs using LSP.

2.9k installsAudited
UNunsafe-checker logo

unsafe-checker

actionbook/rust-skills

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

2.9k installsAudited
COcoding-guidelines logo

coding-guidelines

actionbook/rust-skills

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

3.6k installsAudited
ESesp32-firmware-engineer logo

esp32-firmware-engineer

adamlipecz/esp32-firmware-engineer-skill

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.

722 installs
APapi-and-interface-design logo

api-and-interface-design

addyosmani/agent-skills

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

43k installs