home / skills / zhanghandong / rust-skills / rust-skill-creator

rust-skill-creator skill

safe

This skill helps you generate dynamic Rust crate and std library skills from documentation URLs, accelerating llms-based skill creation.

npx playbooks add skill zhanghandong/rust-skills --skill rust-skill-creator

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.8 KB

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

> 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

## 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]
```

## 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

```
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 Std Library Skill

```
User: "Create a skill for Send and Sync traits"

Claude:
1. Identify: Std library traits
2. 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
3. Wait for llms.txt generation
4. Execute: /create-skills-via-llms std-marker ~/tmp/{timestamp}-std-marker-llms.txt
```

### Example 3: Custom URL

```
User: "Create skill from https://docs.rs/sqlx/latest/sqlx/"

Claude:
1. Identify: User-provided URL
2. Execute: /create-llms-for-skills https://docs.rs/sqlx/latest/sqlx/
3. Follow standard workflow
```

## DO NOT

- Use `best-skill-creator` for Rust-related skill creation
- Skip the `/create-llms-for-skills` step
- Guess documentation URLs without verification

## Output Location

All generated skills are saved to: `~/.claude/skills/`

Overview

This skill creates dynamic AI assistant skills from Rust crate and standard library documentation. It automates extracting documentation content and preparing LLM-ready inputs so you can generate targeted skills for crates, modules, types, and traits. Use it to produce focused skills for libraries like tokio, serde, axum, or any rustdoc URL.

How this skill works

The skill identifies the documentation target from a short request or a full URL, builds the correct docs.rs or doc.rust-lang.org link, and runs a crawler to generate an llms.txt payload. After llms.txt is produced, it invokes a skill-generation step that converts the payload into a reusable skill saved to the local skills directory. Commands are provided for both the llm extraction step and the subsequent skill creation step.

When to use it

You need a dynamic assistant for a third-party crate (tokio, serde, axum, etc.).
You want a skill covering Rust standard library items (traits, structs, modules).
You have a specific documentation URL to convert into a skill.
You want repeatable, versioned skills tied to crate documentation.
You need focused skills (e.g., routing, extractors, async primitives).

Best practices

Provide exact crate names or full doc URLs to avoid guessing the correct doc page.
Run the /create-llms-for-skills step first and verify llms.txt before creating skills.
When targeting std items, use the documented path templates to construct URLs.
Include short requirements or focus areas (e.g., "Focus on error handling") to shape the generated skill.
Pin a crate version when reproducibility is required.

Example use cases

Create a tokio skill that focuses on runtime, tasks, and synchronization primitives.
Generate a serde skill that highlights serialization patterns and custom derives.
Produce a std::sync skill covering Arc, Mutex, and RwLock with usage examples.
Convert a user-provided docs.rs URL for sqlx into a query and connection management skill.
Build a small skill for the Send and Sync traits to explain thread-safety rules.

FAQ

What commands are used to create a skill from docs?

First run /create-llms-for-skills <url> [requirements] to generate llms.txt, then run /create-skills-via-llms <crate_name> <llms_path> [version] to produce the final skill.

How do I construct URLs for std items?

Use the doc.rust-lang.org templates, for example std/{module}/trait.{Name}.html or std/{module}/struct.{Name}.html; verify the URL before running extraction.