Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
actionbook avatar

Core Dynamic Skills

  • 749 installs
  • 1.4k repo stars
  • Updated May 24, 2026
  • actionbook/rust-skills

core-dynamic-skills is a Rust agent skill that implements dynamic loading, shared core patterns, and composable capability modules for developers building CLI or API agents that need extensible skill runtimes.

About

core-dynamic-skills is a skill from actionbook/rust-skills for implementing or extending Rust-based agent skills with dynamic loading, shared core patterns, and composable capability modules. It targets developers wiring CLI or API agents where capabilities should load at runtime instead of compiling every integration statically. The patterns emphasize reusable core crates, modular skill boundaries, and composition so new agent abilities can ship without rewriting the host runtime. Reach for core-dynamic-skills when scaffolding a Rust agent host, refactoring monolithic command handlers into plug-in skills, or aligning multiple agent integrations on one shared core. It assumes comfort with Rust modules, trait boundaries, and agent orchestration rather than one-off scripting.

  • Rust-first dynamic skill patterns
  • Composable core capability modules
  • Runtime skill registration hooks
  • CLI and API agent targets
  • actionbook/rust-skills conventions

Core Dynamic Skills by the numbers

  • 749 all-time installs (skills.sh)
  • Ranked #26 of 121 Rust skills by installs in the Skillselion catalog
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/actionbook/rust-skills --skill core-dynamic-skills

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs749
repo stars1.4k
Last updatedMay 24, 2026
Repositoryactionbook/rust-skills

How do you build dynamic Rust agent skills?

Implement or extend Rust-based agent skills with dynamic loading, shared core patterns, and composable capability modules for CLI or API agents.

Who is it for?

Rust developers architecting CLI or API agents that need plug-in skills and shared core crates instead of static command bundles.

Skip if: Quick Python or Node agent prototypes that do not require Rust module boundaries or runtime skill loading.

When should I use this skill?

The user asks to implement, extend, or refactor Rust agent skills with dynamic loading or composable modules.

What you get

Rust agent host with dynamically loaded skill modules and shared core patterns.

  • Dynamic skill module layout
  • Shared core pattern crate structure

Files

SKILL.mdMarkdownGitHub ↗

Dynamic Skills Manager

Version: 2.1.0 | Last Updated: 2025-01-27

Orchestrates on-demand generation of crate-specific skills based on project dependencies.

Concept

Dynamic skills are:

  • Generated locally at ~/.claude/skills/
  • Based on Cargo.toml dependencies
  • Created using llms.txt from docs.rs
  • Versioned and updatable
  • Not committed to the rust-skills repository

Trigger Scenarios

Prompt-on-Open

When entering a directory with Cargo.toml: 1. Detect Cargo.toml (single or workspace) 2. Parse dependencies list 3. Check which crates are missing skills 4. If missing: "Found X dependencies without skills. Sync now?" 5. If confirmed: run /sync-crate-skills

Manual Commands

  • /sync-crate-skills - Sync all dependencies
  • /clean-crate-skills [crate] - Remove skills
  • /update-crate-skill <crate> - Update specific skill

Execution Mode Detection

CRITICAL: Check if agent and command infrastructure is available.

Try to read: ../../agents/ directory Check if /create-llms-for-skills and /create-skills-via-llms commands work.

---

Agent Mode (Plugin Install)

When full plugin infrastructure is available:

Architecture

Cargo.toml
    ↓
Parse dependencies
    ↓
For each crate:
  ├─ Check ~/.claude/skills/{crate}/
  ├─ If missing: Check actionbook for llms.txt
  │     ├─ Found: /create-skills-via-llms
  │     └─ Not found: /create-llms-for-skills first
  └─ Load skill

Workflow Priority

1. actionbook MCP - Check for pre-generated llms.txt 2. /create-llms-for-skills - Generate llms.txt from docs.rs 3. /create-skills-via-llms - Create skills from llms.txt

Sync Command

/sync-crate-skills [--force]

1. Parse Cargo.toml for dependencies 2. For each dependency:

  • Check if skill exists at ~/.claude/skills/{crate}/
  • If missing (or --force): generate skill

3. Report results

---

Inline Mode (Skills-only Install)

When agent/command infrastructure is NOT available, execute manually:

Step 1: Parse Cargo.toml

# Read dependencies
cat Cargo.toml | grep -A 100 '\[dependencies\]' | grep -E '^[a-zA-Z]'

Or use Read tool to parse Cargo.toml and extract:

  • [dependencies] section
  • [dev-dependencies] section (optional)
  • Workspace members (if workspace project)

Step 2: Check Existing Skills

# List existing skills
ls ~/.claude/skills/

Compare with dependencies to find missing skills.

Step 3: Generate Missing Skills

For each missing crate:

# 1. Fetch crate documentation
agent-browser open "https://docs.rs/{crate}/latest/{crate}/"
agent-browser get text ".docblock"
# Save content

# 2. Create skill directory
mkdir -p ~/.claude/skills/{crate}
mkdir -p ~/.claude/skills/{crate}/references

# 3. Create SKILL.md
# Use template from rust-skill-creator inline mode

# 4. Create reference files for key modules
agent-browser open "https://docs.rs/{crate}/latest/{crate}/{module}/"
agent-browser get text ".docblock"
# Save to ~/.claude/skills/{crate}/references/{module}.md

agent-browser close

WebFetch fallback:

WebFetch("https://docs.rs/{crate}/latest/{crate}/", "Extract API documentation overview, key types, and usage examples")

Step 4: Workspace Support

For Cargo workspace projects:

# 1. Parse root Cargo.toml for workspace members
cat Cargo.toml | grep -A 10 '\[workspace\]'

# 2. For each member, parse their Cargo.toml
for member in members; do
  cat ${member}/Cargo.toml | grep -A 100 '\[dependencies\]'
done

# 3. Aggregate and deduplicate dependencies
# 4. Generate skills for missing crates

Clean Command (Inline)

# Clean specific crate
rm -rf ~/.claude/skills/{crate_name}

# Clean all generated skills
rm -rf ~/.claude/skills/*

Update Command (Inline)

# Remove old skill
rm -rf ~/.claude/skills/{crate_name}

# Re-generate (same as sync for single crate)
# Follow Step 3 above for the specific crate

---

Local Skills Directory

~/.claude/skills/
├── tokio/
│   ├── SKILL.md
│   └── references/
├── serde/
│   ├── SKILL.md
│   └── references/
└── axum/
    ├── SKILL.md
    └── references/

---

Related Commands

  • /sync-crate-skills - Main sync command
  • /clean-crate-skills - Cleanup command
  • /update-crate-skill - Update command
  • /create-llms-for-skills - Generate llms.txt (Agent Mode only)
  • /create-skills-via-llms - Create skills from llms.txt (Agent Mode only)

Error Handling

ErrorCauseSolution
Commands not foundSkills-only installUse inline mode
Cargo.toml not foundNot in Rust projectNavigate to project root
docs.rs unavailableNetwork issueRetry or skip crate
Permission deniedDirectory issueCheck ~/.claude/skills/ permissions

Related skills

FAQ

What does core-dynamic-skills help Rust developers build?

core-dynamic-skills helps Rust developers build agent hosts with dynamic skill loading, shared core patterns, and composable capability modules suitable for CLI or API agents.

When should core-dynamic-skills be used?

core-dynamic-skills should be used when extending or implementing Rust agent skills that must load at runtime and share a common core instead of compiling every integration statically.

Rustbackendintegrations

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.