Generate AI agent skills from your NPM dependencies.

Why?

When using new packages or migrating to new versions, agents often struggle to use the appropriate best practices. This is because agents have knowledge cutoffs and predict based on existing patterns.

Methods of getting the right context to your agent require either manual curation, author opt-in, external servers or vendor lock-in. See the landscape for more details.

Skilld generates agent skills from the references maintainers already create: docs, release notes and GitHub issues. With these we can create version-aware, local-first, and optimized skills.

Features

• 🌍 Any Source: Opt-in - Any NPM dependency or GitHub source, docs auto-resolved
• 📦 Bleeding Edge Context - Latest issues, discussions, and releases. Always use the latest best practices and avoid deprecated patterns.
• 📚 Opt-in LLM Sections - Enhance skills with LLM-generated Best Practices, API Changes, or your own custom prompts
• 🧩 Use Any Agent - Choose your agent: CLI , pi agents or no agent at all.
• 🔍 Semantic Search - Query indexed docs across all skills via retriv embeddings
• 🧠 Context-Aware - Follows Claude Code skill best practices: SKILL.md stays under 500 lines, references are separate files the agent discovers on-demand - not inlined into context
• 🎯 Safe & Versioned - Prompt injection sanitization, version-aware caching, auto-updates on new releases
• 🤝 Ecosystem - Compatible with npx skills and skills-npm. Skilld auto-detects and uses skills-npm packages when available.

Quick Start

Run skilld in a project to generate skills for your dependencies through a simple interactive wizard:

npx -y skilld

Requires Node 22.6.0 or higher.

Or add a specific package directly:

npx -y skilld add vue

If you need to re-configure skilld, just run npx -y skilld config to update your agent, model, or preferences.

No agent CLI? No problem - choose "No agent" when prompted. You get a base skill immediately, plus portable prompts you can run in any LLM:

npx -y skilld add vue
# Choose "No agent" -> base skill + prompts exported
# Paste prompts into ChatGPT/Claude web, save outputs, then:
npx -y skilld assemble

Tips

• Be selective - Only add skills for packages your agent struggles with. Not every dependency needs one.
• LLM is optional - Skills work without any LLM, but enhancing with one makes them significantly better.
• Multi-agent - Run skilld install --agent gemini-cli to sync skills to another agent. The doc cache is shared.

Installation

Global

Install globally to use skilld across all projects without npx:

npm install -g skilld
# or
pnpm add -g skilld

Then run skilld in any project directory.

Per-Project

If you'd like to install skilld and track the lock file references, add it as a dev dependency:

npm install -D skilld
# or
yarn add -D skilld
# or
pnpm add -D skilld

Automatic Updates

Add to package.json to restore references and sync shipped skills on install:

{
  "scripts": {
    "prepare": "skilld prepare"
  }
}

This restores symlinks, auto-installs shipped skills from your deps, and notifies you when packages have new features or breaking changes. Run skilld update to regenerate LLM enhancements.

FAQ

Why don't the skills run?

Try this in your project/user prompt:

Before modifying code, evaluate each installed skill against the current task.
For each skill, determine YES/NO relevance and invoke all YES skills before proceeding.

How is this different from Context7?

Context7 is an MCP that fetches raw doc chunks at query time. You get different results each prompt, no curation, and it requires their server. Skilld is local-first: it generates a SKILL.md that lives in your project, tied to your actual package versions. No MCP dependency, no per-prompt latency, and it goes further with LLM-enhanced sections, prompt injection sanitization, and semantic search.

Will I be prompt injected?

Skilld pulls issues from GitHub which could be abused for potential prompt injection.

Skilld treats all data as untrusted, running in permissioned environments and using best practices to avoid injections. However, always be cautious when using skills from untrusted sources.

Do skills update when my deps update?

Yes. Add skilld prepare to your prepare script. It restores references, auto-installs shipped skills, and tells you when packages are outdated. Run skilld update to regenerate LLM enhancements.

CLI Usage

# Interactive mode - auto-discover from package.json
skilld

# Add skills for specific package(s)
skilld add vue nuxt pinia

# Update outdated skills
skilld update
skilld update tailwindcss

# Search docs across installed skills
skilld search "useFetch options" -p nuxt
skilld search "error" -p nuxt --filter '{"type":"issue"}'
skilld search --guide -p nuxt

# Target a specific agent
skilld add react --agent cursor

# Install globally to ~/.claude/skills
skilld add zod --global

# Skip prompts
skilld add drizzle-orm --yes

# Check skill info
skilld info

# List installed skills
skilld list
skilld list --json

# Manage settings
skilld config

Commands

| Command | Description | |---------|-------------| | skilld | Interactive wizard (first run) or status menu (existing skills) | | skilld add <pkg...> | Add skills for package(s), space or comma-separated | | skilld update [pkg] | Update outdated skills (all or specific) | | skilld search [query] | Search indexed docs (-p package, --filter JSON, --limit, --guide) | | skilld list | List installed skills (--json for machine-readable output) | | skilld info | Show skill info and config | | skilld config | Configure agent, model, preferences | | skilld install | Restore references from lockfile | | skilld remove | Remove installed skills | | skilld uninstall | Remove all skilld data | | skilld cache | Cache management (clean expired LLM cache entries) | | skilld eject <pkg> | Eject skill as portable directory (no symlinks) | | skilld assemble [dir] | Merge LLM output files back into SKILL.md (auto-discovers) |

Works Without an Agent CLI

No Claude, Gemini, or Codex CLI? Choose "No agent" when prompted. You get a base skill immediately, plus portable prompts you can run in any LLM to enhance it:

skilld add vue
# Choose "No agent" -> installs to .claude/skills/vue-skilld/

# What you get:
#   SKILL.md           <- base skill (works immediately)
#   PROMPT_*.md        <- prompts to enhance it with any LLM
#   references/        <- docs, issues, releases as real files

# Run each PROMPT_*.md in ChatGPT/Claude web/any LLM
# Save outputs as _BEST_PRACTICES.md, _API_CHANGES.md, then:
skilld assemble

skilld assemble auto-discovers skills with pending output files. skilld update re-exports prompts for outdated packages.

Eject

Export a skill as a portable, self-contained directory for sharing via git repos:

skilld eject vue                    # Default skill directory
skilld eject vue --name vue         # Custom directory name
skilld eject vue --out ./skills/    # Custom path
skilld eject vue --from 2025-07-01  # Only recent releases/issues

Share via skilld add owner/repo - consumers get fully functional skills with no LLM cost.

CLI Options

| Option | Alias | Default | Description | |--------|-------|---------|-------------| | --global | -g | false | Install globally to ~/<agent>/skills | | --agent | -a | auto-detect | Target specific agent (claude-code, cursor, etc.) | | --yes | -y | false | Skip prompts, use defaults | | --force | -f | false | Ignore all caches, re-fetch docs and regenerate | | --model | -m | config default | LLM model for skill generation (sonnet, haiku, opus, etc.) | | --name | -n | | Custom skill directory name (eject only) | | --out | -o | | Output directory path override (eject only) | | --from | | | Collect releases/issues/discussions from this date (YYYY-MM-DD, eject only) | | --debug | | false | Save raw LLM output to logs/ for each section |

For Maintainers

Ship skills with your npm package so consumers get them automatically. No LLM needed on their end.

Generate a skill

From your package root (or monorepo root):

npx skilld author

In a monorepo, skilld auto-detects workspaces and prompts which packages to generate for. Docs are resolved from: package docs/, monorepo docs/content/, llms.txt, or README.md.

This creates a skills/<your-package>/ directory with a SKILL.md and ejected reference files. It also adds "skills" to your package.json files array.

How consumers get it

Once published, consumers run:

npx skilld prepare

Or add it to their package.json so it runs on every install:

{
  "scripts": {
    "prepare": "skilld prepare"
  }
}

skilld prepare auto-detects shipped skills in node_modules and symlinks them into the agent's skill directory. Compatible with skills-npm.

Options

| Flag | Alias | Default | Description | |:----------|:-----:|:-------:|:------------| | --model | -m | | LLM model for enhancement | | --out | -o | | Output directory (single package only) | | --force | -f | false | Clear cache and regenerate | | --yes | -y | false | Skip prompts, use defaults | | --debug | | false | Save raw LLM output to logs/ |

The Landscape

Several approaches exist for steering agent knowledge. Each fills a different niche:

| Approach | Versioned | Curated | No Opt-in | Local | Any LLM | |:---------|:---------:|:-------:|:---------:|:-----:|:-------:| | Manual rules | - | yes | yes | yes | yes | | llms.txt | ~ | - | - | - | yes | | MCP servers | yes | - | - | - | - | | skills.sh | - | ~ | yes | - | - | | skills-npm | yes | yes | - | yes | - | | skilld | yes | yes | yes | yes | yes |

Versioned - tied to your installed package version. Curated - distilled best practices, not raw docs. No Opt-in - works without the package author doing anything. Local - runs on your machine, no external service dependency. Any LLM - works with any LLM, not just agent CLIs.

• Manual rules (CLAUDE.md, .cursorrules): full control, but you need to already know the best practices and maintain them across every dep.
• llms.txt: standard convention for exposing docs to LLMs, but it's full docs not curated guidance and requires author adoption.
• MCP servers (Context7, etc.): live, version-aware responses, but adds per-request latency and the maintainer has to build and maintain a server.
• skills.sh: easy skill sharing with a growing ecosystem, but community-sourced without version-awareness or author oversight.
• skills-npm: the ideal end-state: zero-token skills shipped by the package author, but requires every maintainer to opt in. Skilld auto-detects and uses skills-npm packages when available.
• skilld: generates version-aware skills from existing docs, changelogs, issues, and discussions. Works for any package without author opt-in.

Telemetry

Skilld sends anonymous install events to skills.sh so skills can be discovered and ranked. No personal information is collected.

Telemetry is automatically disabled in CI environments.

To opt out, set either environment variable:

DISABLE_TELEMETRY=1
DO_NOT_TRACK=1

Related

• skills-npm - Convention for shipping agent skills in npm packages
• agentskills.io - Agent skills specification
• mdream - HTML to Markdown converter
• retriv - Vector search with sqlite-vec

License

Licensed under the MIT license.