🎯

rust-skill-creator

🎯Skill

from goooice/rust-skills

VibeIndex|
What it does

Dynamically generates Claude skills for Rust crates, standard library modules, and documentation by extracting and processing technical details from specified URLs.

πŸ“¦

Part of

goooice/rust-skills(35 items)

rust-skill-creator

Installation

Add MarketplaceAdd marketplace to Claude Code
/plugin marketplace add ZhangHanDong/rust-skills
Install PluginInstall plugin from marketplace
/plugin install rust-skills@rust-skills
Quick InstallInstall with npx
npx skills add ZhangHanDong/rust-skills
git cloneClone repository
git clone https://github.com/ZhangHanDong/rust-skills.git
πŸ“– Extracted from docs: goooice/rust-skills
4Installs
-
AddedFeb 4, 2026

Skill Details

SKILL.md

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

Overview

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

More from this repository10

🎯
m14-mental-model🎯Skill

Applies the M14 mental model framework to enhance decision-making and strategic thinking through structured cognitive analysis.

🎯
m04-zero-cost🎯Skill

Guides developers in choosing zero-cost abstractions by analyzing type system constraints and performance trade-offs in Rust generics and traits.

🎯
m10-performance🎯Skill

Optimizes code performance by identifying bottlenecks, measuring impact, and guiding strategic improvements across algorithm, data structure, and memory efficiency.

🎯
meta-cognition-parallel🎯Skill

Performs parallel three-layer meta-cognitive analysis by forking subagents to simultaneously analyze language mechanics, design choices, and domain constraints, then synthesizing results.

🎯
unsafe-checker🎯Skill

Identifies and reviews unsafe Rust code patterns, FFI risks, and potential memory unsafety in Rust projects.

🎯
coding-guidelines🎯Skill

Provides comprehensive Rust coding guidelines covering naming conventions, best practices, error handling, memory management, concurrency, and code style recommendations.

🎯
rust-refactor-helper🎯Skill

Performs safe Rust refactoring by analyzing symbol references, checking conflicts, and applying changes across project files using LSP.

🎯
m03-mutability🎯Skill

Diagnoses and guides resolution of Rust mutability and borrowing conflicts by analyzing ownership, mutation patterns, and thread-safety requirements.

🎯
domain-iot🎯Skill

Enables building robust, efficient IoT applications with offline-first design, power-aware networking, and secure device communication using Rust.

🎯
m05-type-driven🎯Skill

Explores and demonstrates type-driven development techniques in Rust, showcasing advanced type system features and pattern matching strategies.