Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.gofastskill.com/llms.txt

Use this file to discover all available pages before exploring further.

​
Welcome to FastSkill

Package manager and operational toolkit for Agent AI Skills. FastSkill enables discovery, installation, versioning, and deployment of skills at scale. It follows the Claude Code skill layout (SKILL.md) and adds manifests, lockfiles, validation, optional eval suites, search, and agent sync so teams can operate skills—not only host a catalog.

​
The Problem We’re Solving

AI agent skills are scattered across repositories with no standard way to discover, version, or manage them. FastSkill brings package management to AI skills, solving:
  • Discovery: Skills scattered across repos with no search or discovery mechanism
  • Versioning: No version control or reproducible deployments
  • Dependencies: Manual dependency management with runtime conflicts
  • Environments: Hard to keep optional tools separate from what production agents need
  • Integration: Each project reinvents skill loading and management

​
How FastSkill Solves These Problems

FastSkill extends the Claude Code skill standard with a manifest-first workflow: one skill-project.toml, reproducible installs via skills.lock, validation and fastskill eval for quality gates, then discovery and optional publish when you distribute outward.

​
Semantic discovery

Find skills by meaning, not just keywords. FastSkill uses OpenAI embeddings to enable semantic search—find skills by what they do, not just what they’re called. This means you can search for “powerpoint presentation” and find skills that create presentations, even if they don’t use those exact words. 
# Semantic search finds skills by meaning
fastskill search "create data visualizations"
# Returns: chart-generator, dashboard-builder, data-plotter

​
Package management for skills

Declarative skill management, similar to npm for Node.js or Poetry for Python. FastSkill uses a unified skill-project.toml file at the project root for all configuration, similar to pyproject.toml and package.json: 
# skill-project.toml - Unified configuration
[dependencies]
web-scraper = { source = "git", url = "https://github.com/org/repo.git", branch = "main" }
pytest = { source = "source", name = "team-tools", skill = "pytest", groups = ["dev"] }
Benefits:
  • Reproducible installs: skills.lock preserves exact versions
  • Groups: optional vs production skill sets
  • Version tracking: update when you choose
  • Unified config: dependencies and repositories in one manifest

​
Lifecycle commands

fastskill init                    # Skill author: create skill-project metadata
fastskill add ./my-skill -e       # Add or link a skill (editable when local)
fastskill install --without dev   # Install manifest without dev-only groups
fastskill update                  # Move pinned versions forward when you choose
fastskill show --tree             # Inspect what is installed
fastskill eval validate           # Check eval config and prompts (optional)
fastskill sync --yes              # Write installed skills to agent metadata

​
Dependency management

Automatic resolution with conflict detection. Skills declare dependencies that FastSkill resolves automatically: 
[dependencies]
web-scraper = { source = "registry", name = "team-tools", version = "^1.0" }
data-processor = { source = "git", url = "https://github.com/org/data.git" }

​
Version control and automation

fastskill add https://github.com/org/skill.git
git add skill-project.toml skills.lock
git commit -m "Add data processing skill"
In automation, the same commands apply: install the fastskill binary in the environment, check out your repo, then run fastskill install --lock (and set secrets for tokens or API keys).

​
Multi-environment manifests

Different skill sets for different environments: 
[dependencies]
# Development environment gets extra tools
dev-tools = { source = "source", name = "registry", skill = "dev-tools", groups = ["dev"] }

# Production gets monitoring
monitoring = { source = "source", name = "registry", skill = "monitoring", groups = ["prod"] }

​
Performance

Pre-computed embeddings and efficient storage. FastSkill includes performance optimizations that make skill management scalable: Pre-computed Embeddings:
  • Skills can bundle pre-computed embeddings in ZIP packages
  • No API calls needed during installation
  • Faster search and discovery
  • Consistent embeddings across installations
Local Vector Storage:
  • SQLite-based embedding database
  • Fast semantic search without external API calls
  • Offline operation capability
  • Incremental indexing for efficiency

​
Expanding the Claude Code Standard

FastSkill builds on the Anthropic Claude Code skill standard (SKILL.md) and adds operational depth around it:

​
1. Package management & lifecycle

  • Manifests & locks: skill-project.toml and skills.lock like other package ecosystems
  • Install / update / remove: Same verbs you expect from a package manager
  • Groups: optional vs production skill sets
  • Editable installs: point at local folders while authoring

​
2. Validation & evals

  • Install-time checks: structure and metadata when skills are added or installed
  • Reconciliation: fastskill list compares manifest, lock, and disk (see Skill validation)
  • Eval suites: fastskill eval for validate / run / report / score against defined cases (eval command)

​
3. Discovery & agent sync

  • Search: remote catalogs by default; --local for installed skills and embeddings
  • Read & show: inspect what agents will load
  • Sync: push the installed set into agent metadata files (fastskill sync)

​
4. Publish & registries (when you distribute)

  • Package: ZIP artifacts with versioning
  • Publish: API or local folder targets when you ship skills to others
  • Repositories: fastskill repos for catalog sources—not the only story; many teams spend most time in install, list, validate, and eval

​
Key Features

​
Declarative configuration

Define your skills declaratively in skill-project.toml at your project root: 
# skill-project.toml
[dependencies]
web-scraper = { source = "git", url = "https://github.com/org/repo.git", branch = "main" }
data-processor = { source = "source", name = "team-tools", skill = "data-processor", groups = ["prod"] }

​
Reproducible installs

Lock files ensure exact reproducibility: 
# skills.lock - Exact installed state
[[skills]]
id = "web-scraper"
version = "1.2.3"
commit_hash = "abc123def456"
fetched_at = "2024-01-01T12:00:00Z"

​
Group-based organization

Organize skills by environment: 
# Install all skills
fastskill install

# Install without dev group
fastskill install --without dev

# Install only production
fastskill install --only prod

​
Editable installs

Point FastSkill at a folder on disk while you iterate: 
# Install in editable mode
fastskill add ./local-skill -e --group dev

​
Repositories

fastskill repos add team-tools --repo-type git-marketplace https://github.com/org/skills.git
fastskill repos list
fastskill install
Find skills by meaning: 
# Search by capability
fastskill search "create presentations"

# Find visualization tools
fastskill search "charts and graphs"

​
Use Cases

​
Individuals

Manage a personal skill library:
  • Track skills you use across projects
  • Version control your skill configurations
  • Update skills safely
  • Discover new skills by capability

​
Teams

Share skill configurations:
  • Standardize skill sets across team members
  • Separate optional skills from production sets
  • Track skill updates in version control
  • Collaborate on skill selection

​
Organizations

Operate skills at scale:
  • Standard manifests and locks across projects
  • Auditing via list/show and validation
  • Environment-specific groups
  • Optional private sources and publish flows when you distribute

​
Skill Authors

Author, check, then ship:
  • fastskill init and packaging for versioned ZIPs
  • Validation and fastskill eval before release
  • Dependencies declared in the manifest
  • Distribute via Git, ZIP, or registries when needed

​
Getting Started

Ready to get started? Here’s a quick path:
  1. Install FastSkill - CLI on your PATH
  2. Quick Start - First manifest, install, search
  3. Skill validation - Reconciliation and checks
  4. Evals and quality - Setup, runs, reports, and cluster analysis
  5. CLI reference - All commands and flags

​
Why FastSkill?

FastSkill focuses on repeatable operations for AI agent skills:
  • Reproducibility: lock files for consistent installs
  • Scale: many skills and repositories in one project
  • Collaboration: shared manifests and locks
  • Reliability: explicit versions and dependency entries
  • Performance: optional precomputed embeddings in packages
  • Standards-based: Claude Code SKILL.md layout

​
What’s Next?

FastSkill: Package manager and operational toolkit for Agent AI Skills—manageable, versioned, and reproducible.