
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-skillsAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 749 |
|---|---|
| repo stars | ★ 1.4k |
| Last updated | May 24, 2026 |
| Repository | actionbook/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
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 skillWorkflow 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 closeWebFetch 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 cratesClean 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
| Error | Cause | Solution |
|---|---|---|
| Commands not found | Skills-only install | Use inline mode |
| Cargo.toml not found | Not in Rust project | Navigate to project root |
| docs.rs unavailable | Network issue | Retry or skip crate |
| Permission denied | Directory issue | Check ~/.claude/skills/ permissions |
policy:
allow_implicit_invocation: false
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.