Skip to content
Back to search

skilld

Open-source, privacy friendly skills.sh alternative for humans and agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/skilld-dev/skilld with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/skilld-dev/skilld'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/skilld-dev--skilld/badge.svg)](/listings/skilld-dev--skilld)

HTML

<a href="/listings/skilld-dev--skilld"><img src="/api/listings/skilld-dev--skilld/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

macOS and Linux:

curl -fsSL https://github.com/skilld-dev/skilld/releases/latest/download/install.sh | sh

Windows PowerShell:

irm https://github.com/skilld-dev/skilld/releases/latest/download/install.ps1 | iex

The script installs one native binary to `~/.skilld/bin`. That install upgrades itself in the background after it verifies the signed release manifest. Restart skilld to use the new version. An npm install prints the upgrade command instead. Set `SKILLD_NO_UPGRADE=1` to turn off upgrade checks. See [SECURITY.md](./SECURITY.md#how-the-cli-upgrades-itself) for each check.

The npm package selects the same native executable for your system. It carries no JavaScript engine and no fallback.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 22 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "skilld",
  3. "description": "Curated Agent Skills from skilld.dev, with the skilld CLI Skill and the registry MCP server.",
  4. "owner": {
  5. "name": "skilld",
  6. "url": "https://skilld.dev"
  7. },
  8. "plugins": [
  9. {
  10. "name": "skilld",
  11. "source": "./",
  12. "description": "The skilld-maintained Skills and the skilld.dev discovery MCP server. Search curated Skills, then run or install them with the skilld CLI.",
  13. "homepage": "https://skilld.dev/developers",
  14. "mcpServers": {
  15. "skilld": {
  16. "type": "http",
  17. "url": "https://skilld.dev/api/mcp"
  18. }
  19. }
  20. }
  21. ]
  22. }
README.md · README · 678 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <h1 align="center">
  2. <a href="https://skilld.dev"><picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/skilld-dev/skilld/main/.github/logos/logo.svg">
  4. <img alt="skilld" src="https://raw.githubusercontent.com/skilld-dev/skilld/main/.github/logos/logo-light.svg" width="260">
  5. </picture></a>
  6. </h1>
  7. <p align="center">
  8. Find, preview, run, and watch Agent Skills.<br>The open-source CLI behind <a href="https://skilld.dev">skilld.dev</a>.
  9. </p>
  10. <p align="center">
  11. <a href="https://npmjs.com/package/skilld"><img alt="npm version" src="https://img.shields.io/npm/v/skilld?style=flat&labelColor=1c1917&color=e11d48"></a>
  12. <a href="https://npm.chart.dev/skilld"><img alt="npm downloads" src="https://img.shields.io/npm/dm/skilld?style=flat&labelColor=1c1917&color=e11d48"></a>
  13. <a href="https://github.com/skilld-dev/skilld/blob/main/LICENSE"><img alt="license" src="https://img.shields.io/github/license/skilld-dev/skilld?style=flat&labelColor=1c1917&color=e11d48"></a>
  14. <a href="https://skilld.dev/gh/skilld-dev/skilld/skilld"><picture>
  15. <source media="(prefers-color-scheme: dark)" srcset="https://skilld.dev/b/skilld-dev/skilld/skilld?theme=dark">
  16. <source media="(prefers-color-scheme: light)" srcset="https://skilld.dev/b/skilld-dev/skilld/skilld?theme=light">
  17. <img alt="Agent skill on skilld.dev" src="https://skilld.dev/b/skilld-dev/skilld/skilld?theme=light">
  18. </picture></a>
  19. </p>
  20. <div align="center">
  21. <table>
  22. <tbody>
  23. <tr>
  24. <td align="center">
  25. <sub>Made possible by my <a href="https://github.com/sponsors/harlan-zw">Sponsor Program 💖</a><br> Follow me <a href="https://twitter.com/harlan_zw">@harlan_zw</a> 🐦 • Join <a href="https://discord.gg/275MBUBvgP">Discord</a> for help</sub>
  26. </td>
  27. </tr>
  28. </tbody>
  29. </table>
  30. </div>
  31. ## What is skilld?
  32. [skilld.dev](https://skilld.dev) is a curated registry of Agent Skills.
  33. Real maintainers write them in their own GitHub Repositories.
  34. skilld.dev and the open-source `skilld` CLI cover four steps:
  35. | Step | What you do | Where |
  36. | --- | --- | --- |
  37. | 🔥 **Find** | See the Skills devs talk about this week. | [Trending Skills](https://skilld.dev/skills/trending), `skilld trending`, `skilld search` |
  38. | 🧑‍🎨 **Preview** | See what a Skill makes before you run it. | [Skill demos](https://skilld.dev/skills/demos) |
  39. | 🏃‍♂️ **Run** | Run a Skill once, fork it, or install it. | `skilld run`, `skilld install` |
  40. | 👀 **Watch** | Get a digest when the Skills you use change. | `skilld watch`, `skilld changes` |
  41. A Skill is a directory with a `SKILL.md` file in the [Agent Skills](https://agentskills.io) format.
  42. Most Skill directories rank by install count, or ship a generated doc dump.
  43. skilld names the author, links the exact file, and records the commit it came from.
  44. Read it before your Agent follows it.
  45. The `skilld` CLI searches, runs, installs, updates, verifies, and removes Skills.
  46. It contains no Skill generation logic and no Agent runtime.
  47. Skill authoring lives in visible [skilld-maintained Skills](#author-a-skill) and the optional [Harness](#harness).
  48. ## Features
  49. - 💬 **Ask your Agent to find and run Skills.** Install the `skilld` Skill once, then describe your task. Your Agent searches the registry and loads a Skill for you.
  50. - 📖 **Use a Skill for one task.** Give your Agent a Skill URL and ask it to run the Skill. Loading the instructions writes no files.
  51. - 🎯 **Keep Skills across sessions and Agents.** Ask your Agent to install a Skill when you want to keep it. skilld supports Claude Code, Codex, Cursor, Gemini CLI, Zed, and more.
  52. - 🔏 **Know where a Skill came from.** Remote installs record the exact source commit. Ask your Agent to check for updates when you need them.
  53. - 🛡️ **No telemetry.** The CLI sends no analytics. Account credentials go to your operating system keychain, never to a plain text file.
  54. ## Get started
  55. Install the [`skilld` Skill](https://skilld.dev/gh/skilld-dev/skilld/skilld) so your Agent can find and run Skills:
  56. ```sh
  57. npx skilld install skilld --global
  58. ```
  59. This installs the Skill for your detected Agents across projects.
  60. Start a new Agent session, then ask for what you need:
  61. > Find me a good Skill for reviewing my Vue app.
  62. > Run this Skill: https://skilld.dev/gh/antfu/skills/vue
  63. Your Agent searches the registry, reads the Skill, and follows it for the current task.
  64. To keep a Skill across sessions, ask your Agent to install it.
  65. For setup through your Agent, paste this:
  66. > Read https://skilld.dev/agent.md and follow it to set up skilld for me.
  67. ## Use the CLI
  68. Every command below works through `npx` with no install.
  69. To install the CLI, see [Install the CLI](#install-the-cli).
  70. ### Find a Skill
  71. [Trending Skills](https://skilld.dev/skills/trending) ranks Skills by how many separate devs talked about each one this week.
  72. Search the registry from a terminal:
  73. ```sh
  74. npx skilld search vue
  75. npx skilld trending
  76. ```
  77. Search prints up to 20 Skills, which can be a lot to scan.
  78. Ask for fewer with `npx skilld search vue --limit 5`.
  79. The limit goes from 1 to 50.
  80. Every Skill page credits its author and links the source file on GitHub.
  81. [Curators](https://skilld.dev/community) publish collections of the Skills they use.
  82. ### Preview it
  83. Some Skills have demos.
  84. Each demo is one recorded run: the prompt, and what the Agent built with the Skill.
  85. Browse [every demo](https://skilld.dev/skills/demos), or open the Demo panel on a Skill page.
  86. ### Run it
  87. Give your Agent a Skill URL. There is nothing to install:
  88. > Use this Skill: https://skilld.dev/gh/antfu/skills/vue
  89. Your Agent reads the page and follows it for that session.
  90. Nothing is written to your project.
  91. Add `.md` to any Skill URL for the raw `SKILL.md`.
  92. From a terminal, `skilld run` does the same:
  93. ```sh
  94. npx skilld run antfu/skills/vue
  95. ```
  96. It prints `SKILL.md` to stdout and writes no file.
  97. Pass the output to your Agent.
  98. To change a Skill, ask your Agent to fork it:
  99. > Fork this Skill: https://skilld.dev/gh/antfu/skills/vue
  100. A fork creates an editable local Skill with its original author and license.
  101. To keep a Skill in every session of one project, install it:
  102. ```sh
  103. npx skilld install antfu/skills/vue
  104. ```
  105. An install writes files. If an Agent runs the install, it asks you first.
  106. | | `skilld run` | `skilld install` |
  107. | --- | --- | --- |
  108. | Use it for | The task in front of you | Every session in this project |
  109. | Files written | None | `.skills`, the lockfile, and Agent targets |
  110. | Cleanup | None | `skilld remove` |
  111. | Updates | Loads the source each time | `skilld update` |
  112. | Skill scripts | Never printed or executed | On disk for the Skill to use |
  113. Start with `skilld run`. Install when you reach for the same Skill again.
  114. ### Watch for changes
  115. Sign in, then watch the Repositories and collections you use:
  116. ```sh
  117. npx skilld auth login
  118. npx skilld watch antfu/skills
  119. ```
  120. Each month, the digest email lists what changed. If nothing changed, skilld.dev sends nothing.
  121. `skilld changes` prints the same changes from the last 30 days.
  122. `skilld outdated` and `skilld update` keep your installed Skills current.
  123. ## Install the CLI
  124. macOS and Linux:
  125. ```sh
  126. curl -fsSL https://skilld.dev/install.sh | sh
  127. ```
  128. Windows PowerShell:
  129. ```powershell
  130. irm https://skilld.dev/install.ps1 | iex
  131. ```
  132. npm, which needs Node.js:
  133. ```sh
  134. npm install --global skilld
  135. ```
  136. The script installs one native binary to `~/.skilld/bin`.
  137. It adds that directory to PATH: in your shell profile on macOS and Linux, in your user PATH on Windows.
  138. On macOS and Linux, set `SKILLD_NO_MODIFY_PATH=1` to leave your shell profile alone.
  139. skilld checks for CLI upgrades in the background once a day.
  140. If a newer release is cached, the next terminal invocation offers to upgrade.
  141. Choose `Upgrade now`, `Not now`, or `Don't remind me for this version`.
  142. The script install verifies the signed release manifest before replacing the executable.
  143. Restart skilld to use the new version.
  144. Recognized global npm, pnpm, Yarn, and Bun installs run their package manager after you confirm.
  145. Local and transient installs show upgrade guidance instead.
  146. After an upgrade, run your command again.
  147. Set `SKILLD_NO_UPGRADE=1` to turn off upgrade checks.
  148. See [SECURITY.md](./SECURITY.md#how-the-cli-upgrades-itself) for each check.
  149. The npm package selects the same native executable for your system.
  150. It carries no JavaScript engine and no fallback.
  151. ### Claude Code plugin
  152. The plugin installs the skilld-maintained Skills and adds the skilld.dev MCP server.
  153. Run these in Claude Code:
  154. ```sh
  155. /plugin marketplace add skilld-dev/skilld
  156. /plugin install skilld@skilld
  157. ```
  158. The MCP server searches the registry and returns run and install commands. It never runs a Skill.
  159. For ChatGPT, Claude, Codex, Cursor, and VS Code, see [skilld.dev/developers](https://skilld.dev/developers).
  160. ### Agent targets
  161. Use `--agent` to name a target. Repeat it for several, or use `--agent all`.
  162. `-g` is the short form of `--global`.
  163. ```sh
  164. skilld install skilld -g --agent codex
  165. skilld install skilld -g --agent kiro --agent zed
  166. skilld install skilld -g --agent all
  167. ```
  168. Some targets share a directory with an earlier target, such as `warp` and `pi` with `.agents/skills`.
  169. Detection skips them, so name them with `--agent`.
  170. Run `skilld install --help` for every Agent target value.
  171. ## How runs and installs work
  172. ### Selectors
  173. `OWNER/REPOSITORY/SKILL` names one Skill in the registry.
  174. `OWNER/REPOSITORY` names every Skill in one Repository.
  175. `skilld search` prints the selector for each result.
  176. In `skilld-dev/skills/find-skill`, `skilld-dev/skills` is the Repository and `find-skill` is the Skill directory inside it.
  177. skilld 3.0 printed `skilld:OWNER/REPOSITORY/SKILL` and `gh:OWNER/REPOSITORY`. The CLI still accepts both.
  178. ### Repositories, curators, and collections
  179. `skilld run` with a Repository, curator, or collection ref prints an index.
  180. The index has one line per Skill with its run command. It loads no Skill.
  181. `skilld add` installs the Skills the same ref names. It accepts the `skilld install` flags.
  182. A normal terminal asks which Skills to install when several are listed.
  183. Agents, pipes, CI, and `--plain` require `--all` when several Skills are listed.
  184. One listed Skill installs without a picker. `add` does not support JSON output.
  185. ```sh
  186. skilld add antfu/skills --all --agent codex
  187. ```
  188. Success lists the installed agent paths, exact source commit, and source status.
  189. Read the instructions before your agent uses a Skill.
  190. A Repository that skilld.dev does not list yet falls back to its public GitHub tree.
  191. Listing does not request registry indexing or wait for an index job.
  192. The listed GitHub paths still use hosted delivery by default.
  193. If delivery fails, skilld reports the failure and an explicit direct installation command where possible.
  194. It never switches source paths automatically.
  195. To choose direct installation for a public Repository:
  196. ```sh
  197. skilld add antfu/skills --all --direct --agent codex
  198. ```
  199. This command lists and reads files from GitHub without skilld.dev.
  200. It records `unverified` and checks no Artifact attestation.
  201. Behavior approval still applies. Curator and collection refs require hosted delivery.
  202. `skilld add ./PATH` installs one local Skill. The path must contain its `SKILL.md`.
  203. It does not search a local Repository for several Skills.
  204. ### Supporting files
  205. skilld names the supporting files a Skill carries and prints none of them.
  206. Read one when the instructions call for it:
  207. ```sh
  208. skilld run skilld-dev/skills/find-skill --revision <commit> --file agents/openai.yaml
  209. ```
  210. Use the revision and file-read command from the initial output.
  211. skilld never prints executable or binary files.
  212. A Skill that must run its own script needs an install.
  213. ### Skill behaviors
  214. Every run lists what the Skill files ask an Agent to do, with the file and line.
  215. skilld finds behaviors with the fixed text patterns in `packages/protocol/rules/skill-behaviors.json`.
  216. Markdown that forbids a command does not count as that behavior: "Don't read: `id_rsa`", a table row marked **rejected**, or a list under an "Anti-patterns" heading.
  217. Patterns miss obfuscated code, so an empty list proves nothing.
  218. Five behaviors stop a remote `run`, `install`, or `add` until you approve them:
  219. | id | Skill behavior |
  220. | --- | --- |
  221. | `remote-code` | Runs code downloaded from the network |
  222. | `privilege` | Runs commands as root |
  223. | `credentials` | Reads credential files or tokens |
  224. | `destructive` | Deletes system or home directories |
  225. | `hidden-text` | Contains invisible characters |
  226. A terminal asks you directly.
  227. An Agent, a pipe, or CI gets `BEHAVIOR_CONFIRMATION_REQUIRED` and the exact approval command:
  228. ```sh
  229. skilld run 'github:OWNER/REPOSITORY/SKILL#commit:COMMIT' --allow remote-code
  230. ```
  231. The command pins the commit that skilld checked.
  232. A local or bundled Skill lists its behaviors and never stops.
  233. A Skill that skilld.dev delivered can carry a model reading for each match:
  234. what a language model read the line as, such as a quoted example in a security guide, and why.
  235. The message adds it after the match, as `SKILL.md:7 (model reading: quoted example. REASON)`.
  236. A model reading is no guarantee and changes no approval.
  237. `install`, `add`, and `update` stop the same way and write nothing.
  238. Run the same command again with the `--allow` ids the message names.
  239. `add` installs every other Skill the ref names.
  240. `update` stops only when the new version adds an ask behavior the installed copy lacks.
  241. A lockfile restore and `skilld sync` install the commits already recorded, so they never stop.
  242. ## Commands
  243. ```sh
  244. # Find a Skill
  245. skilld search <query>
  246. # Run a Skill for this session only (start here)
  247. skilld run <selector>
  248. # Read one supporting file that Skill carries
  249. skilld run <selector> --revision <commit> --file <path>
  250. # Install a Skill in the current project, or restore the lockfile
  251. skilld install <selector>
  252. skilld install
  253. # List every Skill a Repository, curator, or collection names
  254. skilld run anthropics/skills
  255. skilld run @harlan-zw
  256. skilld run @harlan-zw/agent-workflow-stack
  257. # Install every Skill one of those refs names
  258. skilld add @harlan-zw/agent-workflow-stack
  259. # Inspect installed Skills
  260. skilld list
  261. skilld view <skill>
  262. # Keep Skills current
  263. skilld outdated
  264. skilld update --check --json
  265. skilld update <skill>
  266. skilld verify <skill>
  267. # Sweep Skill files and review cleanup actions
  268. skilld doctor
  269. skilld doctor ./apps --json
  270. skilld doctor --exclude '**/archive/**'
  271. # Remove a Skill
  272. skilld remove <skill>
  273. ```
  274. Project installs update `.skills/skilld-lock.yaml` and the selected Agent targets.
  275. Use `--global` (or `-g`) for account-level Agent targets.
  276. Use `--mode copy` or `--mode symlink` to control target writes.
  277. ### Review Skill files
  278. `skilld doctor` scans your home directory and opens a terminal UI.
  279. Pass roots to narrow the scan. Use `--json` or `--plain` for a read-only report.
  280. The default scan skips links and ownership metadata outside your home directory.
  281. Pass explicit roots when you need those locations.
  282. Progress shows the current phase, directory counts, and elapsed time.
  283. The scan includes hidden `.claude/skills` directories and lists `CLAUDE.md` and `.claude/commands` files separately.
  284. Default exclude globs prune dependencies, builds, caches, plugin staging, sessions, backups, and fixtures before reading their children.
  285. The scan skips general `~/.local` discovery, including worker homes and cached bundles.
  286. Configured Agent Skill directories and the configured skilld store remain included within the requested scan roots.
  287. Skill symlinks can still resolve into `~/.local`. Their neighboring directories are not scanned.
  288. Configured roots still honor exclude globs. Use `--include-excluded` for a broad `.local` scan.
  289. Git worktrees are skipped, including explicit roots and links into worktrees.
  290. Main checkouts and submodules remain included.
  291. Use `--include-excluded` or `--include-worktrees` when you need those files.
  292. Repeat `--exclude GLOB` to add exclusions. Git internals remain excluded.
  293. Source and plugin files retain their owners.
  294. The first screen recommends reviewing skills.sh migration, unknown installs, ownership problems, and duplicate copies.
  295. Open a recommendation with Enter, choose a project or folder, then choose a Skill. Escape goes back.
  296. Managed installs, plugin Skills, and source directories have separate groups.
  297. Press Tab to cycle through all paths, symlinks, and directories.
  298. Details show symlink destinations and the paths of identical copies. Symlinks are not duplicate copies.
  299. The Symlinks view includes Skills reached through linked parent folders and identifies the folder link.
  300. Counts distinguish physical Skills from linked paths. One Skill can appear in both path views.
  301. Filters only change the view. Cleanup reviews all targets for the selected install.
  302. Choose a Skill, then press `m` to migrate or `d` to remove.
  303. Review affected Agent targets before pressing Enter. Escape cancels.
  304. Press `/` to filter by name, owner, or path. Left and right switch focus between the list and details.
  305. Press `p` for scan problems, `n` for the full notice, or `?` for help.
  306. After cleanup, quitting prints the completed action and backup path to your shell.
  307. Migration keeps the scope and copy or link mode of each observed target.
  308. It verifies source contents, preserves recorded branches, and requests approval for Skill behaviors.
  309. When the recorded Git tree matches the installed files, migration can also replace them with the displayed source commit.
  310. If provenance cannot establish the replacement, migration stops before changing files.
  311. Removal backs up the selected targets and removes only their skills.sh lockfile entry.
  312. Original targets, lock metadata, and `recovery.json` remain under `.skilld-doctor-backups` beside the skilld store.
  313. Unknown Agent targets can also be removed after review.
  314. Declared skilld installs, plugin files, and source directories require their existing owner's workflow.
  315. `--check-sources` checks up to 20 source candidates through skilld.dev.
  316. An exact directory match includes supporting files and executable modes.
  317. A name match alone never establishes provenance.
  318. The report retains scan problems. Exit code 1 means some files could not be checked.
  319. Historical commit searches and project-to-global deduplication are outside this command's current actions.
  320. ### Read the registry
  321. These commands read skilld.dev and need no account:
  322. ```sh
  323. # One Skill, Repository, curator, or collection, with its provenance
  324. skilld view vercel-labs/agent-skills/web-design-guidelines
  325. skilld view vercel-labs/agent-skills
  326. skilld view @harlan-zw
  327. skilld view @harlan-zw/design-engineering-essentials
  328. # Browse by owner, tag, and order
  329. skilld browse --owner vercel-labs --sort likes
  330. # What devs talk about this week, and why each Skill trends
  331. skilld trending
  332. # Tracks, and the Skills of one track
  333. skilld tracks
  334. skilld tracks design
  335. # The curators who publish collections
  336. skilld curators
  337. # Ask skilld.dev to index a Repository, then wait for its Skills
  338. skilld index vercel-labs/agent-skills
  339. ```
  340. `skilld view` with a bare name still shows an installed Skill.
  341. A name with `/` or `@` reads the registry instead.
  342. ### Use your account
  343. These commands act for your skilld.dev account. Run `skilld auth login` first.
  344. ```sh
  345. # Settings: email, digest, weekly, likes-public, repository-indexing
  346. skilld account
  347. skilld account set digest off
  348. # Like Skills. A like also watches the Repository for your digest.
  349. skilld like vercel-labs/agent-skills/web-design-guidelines
  350. skilld unlike vercel-labs/agent-skills/web-design-guidelines
  351. skilld likes
  352. skilld likes @harlan-zw
  353. # Watch Repositories and collections, then read what changed
  354. skilld watch vercel-labs/agent-skills
  355. skilld watch @harlan-zw/design-engineering-essentials
  356. skilld unwatch vercel-labs/agent-skills
  357. skilld watches
  358. skilld changes --since 2026-09-01
  359. # Your GitHub stars that hold Skills
  360. skilld stars import
  361. skilld stars
  362. # Build a collection
  363. skilld collection create picks --title "My picks"
  364. skilld collection add @you/picks vercel-labs/agent-skills/web-design-guidelines --reason "Catches UI mistakes"
  365. skilld collection remove @you/picks vercel-labs/agent-skills/web-design-guidelines
  366. # Index or unpublish your own Repositories
  367. skilld account scan
  368. skilld account unpublish you/skills
  369. # Tokens for CI
  370. skilld tokens
  371. skilld tokens create --label "CI deploy" --ttl-days 90
  372. skilld tokens revoke 412
  373. ```
  374. `skilld tokens create` prints the token once. skilld.dev never shows it again.
  375. Account deletion needs skilld.dev in a browser.
  376. ### JSON output
  377. Use `--json` for stable output with `search`, `run`, `update --check`, `view` of a registry ref, and every command in the two sections above.
  378. The `data` field of each answer is the skilld.dev API answer as skilld.dev sent it.
  379. A command whose API answer has no body returns `"data": null`.
  380. Run `skilld install --help` for every Agent target value.
  381. ## Author a Skill
  382. Run a skilld-maintained Skill, or the Harness, to bootstrap a draft Skill you own.
  383. Use `generate-package-skill` for a package you maintain.
  384. Use `generate-project-skill` for the project you work in.
  385. Edit the draft, commit it to your Repository, and own it from there.
  386. skilld lists it with your name and a link to the file.
  387. ```sh
  388. skilld run skilld-dev/skilld/generate-project-skill
  389. skilld run skilld-dev/skilld/generate-package-skill
  390. ```
  391. A project Skill carries the search commands your Agent repeats against real files.
  392. It replaces the v2 local documentation index.
  393. The skilld-maintained Skills:
  394. - [`skilld`](./skills/skilld): search, run, and install Skills with the CLI
  395. - [`generate-package-skill`](./skills/generate-package-skill): draft a Skill for a package you maintain
  396. - [`update-package-skill`](./skills/update-package-skill): update that Skill after a release, testing only what changed
  397. - [`generate-project-skill`](./skills/generate-project-skill): draft a Skill from a project you maintain
  398. - [`review-skill`](./skills/review-skill): review a Skill before you publish it
  399. - [`skilld-tui-design`](./skills/skilld-tui-design): design and verify terminal output and interactive CLI flows
  400. When you run these Skills directly, you see every instruction and review every change.
  401. ## Artifact delivery
  402. The skilld CLI resolves remote Skills through the skilld.dev API.
  403. GitHub remains the source of truth.
  404. skilld.dev builds an immutable Artifact from an exact Git commit.
  405. The CLI checks its digest, Artifact attestation, check results, and archive before installation.
  406. The CLI stops pending Artifact creation after at most 60 seconds.
  407. Private Repository delivery requires both:
  408. - `skilld auth login` for a skilld.dev account
  409. - Access through the skilld GitHub App installation
  410. Private Artifact responses use short-lived, one-time grants.
  411. The API does not expose private storage addresses.
  412. ### Direct mode
  413. `--direct` fetches a public GitHub Repository without the skilld.dev API.
  414. Explicit GitHub selectors use hosted Artifact delivery unless you add `--direct`.
  415. ```sh
  416. skilld install github:skilld-dev/skilld/skills/skilld --direct --agent codex
  417. ```
  418. The installed Skill receives the `unverified` source status.
  419. Review the Skill before use.
  420. Direct mode never handles private Repositories.
  421. It never falls back to skilld.dev.
  422. ### Source status
  423. - `verified`: skilld checked a skilld.dev Artifact and its attestation.
  424. - `local`: the Skill came from a local directory or a bundled skilld-maintained Skill.
  425. - `unverified`: direct mode fetched the Skill from public GitHub.
  426. `verified` describes provenance checks.
  427. It does not endorse the instructions inside a Skill.
  428. See [SECURITY.md](./SECURITY.md) for what skilld checks and how to report a problem.
  429. ## Account and configuration
  430. ```sh
  431. skilld auth login
  432. skilld auth status
  433. skilld auth logout
  434. skilld config get agent.targets
  435. skilld config set agent.targets codex,claude-code
  436. skilld config list
  437. ```
  438. Native builds store account credentials in the operating system keychain.
  439. The CLI does not store tokens in environment variables or plain text files.
  440. A script or a CI job without a browser can send a skilld token instead.
  441. Create one at skilld.dev/me/cli-tokens/new or with `skilld tokens create`, then set `SKILLD_TOKEN`.
  442. The CLI reads it for that run only, and never stores or refreshes it.
  443. ### Environment variables
  444. | Variable | Effect |
  445. | --- | --- |
  446. | `SKILLD_DATA_DIR` | The directory for global Skills and configuration. The default is `~/.skilld`, or `%LOCALAPPDATA%\skilld` on Windows. |
  447. | `SKILLD_API_URL` | The skilld.dev origin the CLI talks to. The default is `https://skilld.dev`. |
  448. | `SKILLD_TOKEN` | A skilld token to send instead of the stored sign-in. For scripts and CI. |
  449. | `SKILLD_NO_UPGRADE` | Set to `1` to turn off upgrade checks. |
  450. | `SKILLD_NO_WEEKLY` | Set to `1` to turn off the note about the weekly email. |
  451. Use `SKILLD_API_URL` to test a local or preview site:
  452. ```sh
  453. SKILLD_API_URL=http://localhost:3000 skilld search vue
  454. ```
  455. It accepts an HTTPS origin, or an HTTP origin on `localhost` or `127.0.0.1`.
  456. Search, Skill delivery, sign-in, and account commands all use that origin.
  457. Each origin keeps its own sign-in, so a skilld.dev token never goes to another origin.
  458. ## Privacy
  459. The skilld CLI sends no telemetry or analytics.
  460. It makes network requests only for these reasons:
  461. - `skilld search`, `skilld run`, and `skilld install` of a hosted Skill call the skilld.dev API.
  462. - If you signed in, those requests carry your account token.
  463. - The registry commands, such as `skilld browse` and `skilld trending`, call the skilld.dev API without your token.
  464. - The account commands, such as `skilld like` and `skilld watch`, call the skilld.dev API with your token.
  465. - `skilld auth login` sends your computer hostname to name the sign-in. Only you see it on skilld.dev.
  466. - `--direct` fetches public Skills from GitHub.
  467. - `skilld update` compares commits through skilld.dev or the GitHub API.
  468. - At a terminal, the CLI checks GitHub Releases or the npm registry for a new version once a day.
  469. The upgrade check never runs in CI or inside an Agent.
  470. Set `SKILLD_NO_UPGRADE=1` to turn it off.
  471. If you are signed out, a terminal shows a short note about the weekly email.
  472. It prints to stderr at most three times, a week apart, and sends nothing.
  473. It never prints in CI, inside an Agent, or when output is piped.
  474. Set `SKILLD_NO_WEEKLY=1` to turn it off.
  475. ## Harness
  476. Use [`skilld-harness`](./packages/harness) when an application or CI needs strict output checks.
  477. The Harness runs the same visible Skill files through an AI SDK Harness.
  478. See the [`skilld-harness` guide](./packages/harness/README.md) for its full contract.
  479. ## Upgrade from v2
  480. v3 does not import v2 configuration or lockfiles.
  481. Back up v2 state before replacing the CLI.
  482. Follow the [v2 to v3 migration guide](./docs/migrate-v2-to-v3.md).
  483. It maps removed commands and explains rollback limits.
  484. ## Development
  485. ```sh
  486. pnpm install
  487. pnpm test:run
  488. pnpm lint
  489. pnpm typecheck
  490. pnpm build
  491. ```
  492. The Rust workspace owns the skilld CLI.
  493. `packages/harness` owns generation and review execution.
  494. `packages/protocol` owns the Artifact delivery wire contract.
  495. `packages/sdk` owns the public API contract and publishes as `skilld-sdk`.
  496. `skills` owns the visible skilld-maintained Skills.
  497. The WASIp2 build remains an internal proof.
  498. Published packages use native executables only.
  499. ## License
  500. [MIT](./LICENSE)
install.ps1 · Bundled script · 64 lines · 1 finding marked
  1. # Install the skilld CLI without Node.js.
  2. #
  3. # irm https://skilld.dev/install.ps1 | iex
    • Note: Runs a downloaded PowerShell script (iex / Invoke-Expression)
    • Line 3 on GitHub
  4. #
  5. # Environment:
  6. # SKILLD_INSTALL_DIR Install directory. Default: %LOCALAPPDATA%\skilld\bin
  7. # SKILLD_VERSION Exact version to install, for example 3.1.0. Default: latest
  8. #
  9. # PowerShell cannot check Ed25519 signatures, so this script trusts the HTTPS
  10. # download and the SHA-256 digest. The installed CLI verifies the release
  11. # signature before every upgrade.
  12. $ErrorActionPreference = 'Stop'
  13. $repository = 'https://github.com/skilld-dev/skilld'
  14. $arch = switch ($env:PROCESSOR_ARCHITECTURE) {
  15. 'AMD64' { 'x64' }
  16. 'ARM64' { 'arm64' }
  17. default { throw "skilld has no build for $env:PROCESSOR_ARCHITECTURE." }
  18. }
  19. $asset = "skilld-cli-win32-$arch-msvc.exe"
  20. $release = if ($env:SKILLD_VERSION) { "$repository/releases/download/v$env:SKILLD_VERSION" } else { "$repository/releases/latest/download" }
  21. $installDir = if ($env:SKILLD_INSTALL_DIR) { $env:SKILLD_INSTALL_DIR } else { Join-Path $env:LOCALAPPDATA 'skilld\bin' }
  22. $work = Join-Path ([System.IO.Path]::GetTempPath()) ("skilld-" + [System.Guid]::NewGuid())
  23. New-Item -ItemType Directory -Path $work | Out-Null
  24. try {
  25. $manifestPath = Join-Path $work 'skilld-release.txt'
  26. Invoke-WebRequest -UseBasicParsing -Uri "$release/skilld-release.txt" -OutFile $manifestPath
  27. $lines = Get-Content -LiteralPath $manifestPath
  28. if ($lines[0] -ne 'skilld-release-v1' -or $lines[1] -notmatch '^version ([0-9A-Za-z.-]+)$') {
  29. throw 'The release manifest is invalid.'
  30. }
  31. $version = $Matches[1]
  32. $entry = $lines | Where-Object { ($_ -split ' ', 2)[1] -eq $asset } | Select-Object -First 1
  33. if (-not $entry) { throw "The release has no $asset build." }
  34. $expected = ($entry -split ' ', 2)[0]
  35. $binary = Join-Path $work 'skilld.exe'
  36. Invoke-WebRequest -UseBasicParsing -Uri "$release/$asset" -OutFile $binary
  37. if ((Get-FileHash -Algorithm SHA256 -LiteralPath $binary).Hash.ToLowerInvariant() -ne $expected) {
  38. throw 'The downloaded binary does not match its digest. Nothing was installed.'
  39. }
  40. if ((& $binary --version) -ne "skilld $version") {
  41. throw 'The downloaded binary reports the wrong version.'
  42. }
  43. New-Item -ItemType Directory -Force -Path $installDir | Out-Null
  44. $target = Join-Path $installDir 'skilld.exe'
  45. if (Test-Path -LiteralPath $target) {
  46. Move-Item -Force -LiteralPath $target -Destination "$target.old"
  47. }
  48. Move-Item -LiteralPath $binary -Destination $target
  49. Set-Content -LiteralPath (Join-Path $installDir 'skilld-install.json') -Value '{"channel":"standalone"}'
  50. $userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
  51. if (-not (($userPath -split ';') -contains $installDir)) {
  52. [Environment]::SetEnvironmentVariable('Path', "$installDir;$userPath", 'User')
  53. Write-Host "Added $installDir to your PATH. Open a new terminal to use skilld."
  54. }
  55. Write-Host "Installed skilld $version to $target."
  56. }
  57. finally {
  58. Remove-Item -Recurse -Force -LiteralPath $work
  59. }
install.sh · Bundled script · 160 lines · 1 finding marked
  1. #!/bin/sh
  2. # Install the skilld CLI without Node.js.
  3. #
  4. # curl -fsSL https://skilld.dev/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 4 on GitHub
  5. #
  6. # Environment:
  7. # SKILLD_INSTALL_DIR Install directory. Default: $HOME/.skilld/bin
  8. # SKILLD_VERSION Exact version to install, for example 3.1.0. Default: latest
  9. # SKILLD_NO_MODIFY_PATH=1 Leave shell profiles alone. Default: add the install
  10. # directory to PATH in the profile for $SHELL
  11. #
  12. # The installed CLI upgrades itself after it verifies each signed release.
  13. set -eu
  14. RELEASE_PUBLIC_KEY="__SKILLD_RELEASE_PUBLIC_KEY__"
  15. REPOSITORY="https://github.com/skilld-dev/skilld"
  16. fail() {
  17. printf 'skilld install: %s\n' "$1" >&2
  18. exit 1
  19. }
  20. download() {
  21. if command -v curl >/dev/null 2>&1; then
  22. curl --proto '=https' --tlsv1.2 -fsSL "$1" -o "$2"
  23. elif command -v wget >/dev/null 2>&1; then
  24. wget --https-only -q "$1" -O "$2"
  25. else
  26. fail "Install curl or wget, then run this script again."
  27. fi
  28. }
  29. sha256() {
  30. if command -v sha256sum >/dev/null 2>&1; then
  31. sha256sum "$1" | awk '{print $1}'
  32. elif command -v shasum >/dev/null 2>&1; then
  33. shasum -a 256 "$1" | awk '{print $1}'
  34. else
  35. fail "Install sha256sum or shasum, then run this script again."
  36. fi
  37. }
  38. base64url_decode() {
  39. value=$(printf '%s' "$1" | tr '_-' '/+')
  40. case $((${#value} % 4)) in
  41. 2) value="$value==" ;;
  42. 3) value="$value=" ;;
  43. esac
  44. printf '%s' "$value" | openssl base64 -d -A
  45. }
  46. # Verifies the release manifest signature when OpenSSL supports Ed25519.
  47. # Returns 2 when this system cannot check the signature.
  48. verify_signature() {
  49. case "$RELEASE_PUBLIC_KEY" in __*) return 2 ;; esac
  50. command -v openssl >/dev/null 2>&1 || return 2
  51. # DER SubjectPublicKeyInfo for a raw Ed25519 key.
  52. printf '\060\052\060\005\006\003\053\145\160\003\041\000' >"$work/key.der"
  53. base64url_decode "$RELEASE_PUBLIC_KEY" >>"$work/key.der" || return 2
  54. openssl pkey -pubin -inform DER -in "$work/key.der" -out "$work/key.pem" >/dev/null 2>&1 || return 2
  55. printf 'skilld-release-v1\000' >"$work/message"
  56. openssl dgst -sha256 -binary "$work/skilld-release.txt" >>"$work/message" || return 2
  57. base64url_decode "$(tr -d '\n' <"$work/skilld-release.sig")" >"$work/signature" || return 1
  58. openssl pkeyutl -verify -pubin -inkey "$work/key.pem" -rawin \
  59. -in "$work/message" -sigfile "$work/signature" >/dev/null 2>&1 && return 0
  60. # Distinguish a bad signature from an OpenSSL without Ed25519 support.
  61. openssl pkeyutl -help 2>&1 | grep -q -- '-rawin' || return 2
  62. return 1
  63. }
  64. case "$(uname -s)" in
  65. Linux) os=linux ;;
  66. Darwin) os=darwin ;;
  67. *) fail "This script supports Linux and macOS. On Windows, run install.ps1." ;;
  68. esac
  69. case "$(uname -m)" in
  70. x86_64 | amd64) arch=x64 ;;
  71. arm64 | aarch64) arch=arm64 ;;
  72. *) fail "skilld has no build for $(uname -m)." ;;
  73. esac
  74. if [ "$os" = darwin ]; then
  75. asset="skilld-cli-darwin-$arch"
  76. else
  77. libc=gnu
  78. if ls /lib/ld-musl-* >/dev/null 2>&1 || (ldd --version 2>&1 | grep -qi musl); then
  79. libc=musl
  80. fi
  81. asset="skilld-cli-linux-$arch-$libc"
  82. fi
  83. if [ -n "${SKILLD_VERSION:-}" ]; then
  84. release="$REPOSITORY/releases/download/v$SKILLD_VERSION"
  85. else
  86. release="$REPOSITORY/releases/latest/download"
  87. fi
  88. install_dir="${SKILLD_INSTALL_DIR:-$HOME/.skilld/bin}"
  89. work=$(mktemp -d)
  90. trap 'rm -rf "$work"' EXIT INT TERM
  91. download "$release/skilld-release.txt" "$work/skilld-release.txt"
  92. download "$release/skilld-release.sig" "$work/skilld-release.sig"
  93. set +e
  94. verify_signature
  95. signature_status=$?
  96. set -e
  97. case $signature_status in
  98. 0) ;;
  99. 2) printf 'skilld install: OpenSSL cannot check Ed25519 signatures here. Using the HTTPS download and SHA-256 digest only.\n' >&2 ;;
  100. *) fail "The release manifest signature is invalid. Nothing was installed." ;;
  101. esac
  102. [ "$(sed -n 1p "$work/skilld-release.txt")" = "skilld-release-v1" ] || fail "The release manifest is invalid."
  103. version=$(sed -n 2p "$work/skilld-release.txt" | sed -n 's/^version \([0-9A-Za-z.-]*\)$/\1/p')
  104. [ -n "$version" ] || fail "The release manifest has no version."
  105. expected=$(awk -v name="$asset" '$2 == name { print $1 }' "$work/skilld-release.txt")
  106. [ -n "$expected" ] || fail "The release has no $asset build."
  107. download "$release/$asset" "$work/skilld"
  108. [ "$(sha256 "$work/skilld")" = "$expected" ] || fail "The downloaded binary does not match its digest. Nothing was installed."
  109. chmod 755 "$work/skilld"
  110. [ "$("$work/skilld" --version)" = "skilld $version" ] || fail "The downloaded binary reports the wrong version."
  111. mkdir -p "$install_dir"
  112. cp "$work/skilld" "$install_dir/.skilld-install-$$"
  113. mv -f "$install_dir/.skilld-install-$$" "$install_dir/skilld"
  114. printf '{"channel":"standalone"}\n' >"$install_dir/skilld-install.json"
  115. printf 'Installed skilld %s to %s/skilld.\n' "$version" "$install_dir"
  116. case ":$PATH:" in
  117. *":$install_dir:"*) exit 0 ;;
  118. esac
  119. # The profile a new terminal reads for the shell in $SHELL, and the line that
  120. # puts the install directory on PATH there.
  121. case "$(basename "${SHELL:-sh}")" in
  122. zsh) profile="${ZDOTDIR:-$HOME}/.zshrc" ;;
  123. bash) if [ "$os" = darwin ]; then profile="$HOME/.bash_profile"; else profile="$HOME/.bashrc"; fi ;;
  124. fish) profile="${XDG_CONFIG_HOME:-$HOME/.config}/fish/conf.d/skilld.fish" ;;
  125. *) profile="$HOME/.profile" ;;
  126. esac
  127. case "$profile" in
  128. *.fish) path_line="fish_add_path \"$install_dir\"" ;;
  129. *) path_line="export PATH=\"$install_dir:\$PATH\"" ;;
  130. esac
  131. if [ "${SKILLD_NO_MODIFY_PATH:-}" = 1 ]; then
  132. printf 'Add %s to your PATH, then run skilld --version.\n' "$install_dir"
  133. exit 0
  134. fi
  135. # A reinstall finds the line from the last run and adds no second one.
  136. if [ -f "$profile" ] && grep -qF "$path_line" "$profile"; then
  137. :
  138. elif mkdir -p "$(dirname "$profile")" 2>/dev/null && printf '\n# skilld\n%s\n' "$path_line" >>"$profile" 2>/dev/null; then
  139. printf 'Added %s to your PATH in %s.\n' "$install_dir" "$profile"
  140. else
  141. printf 'Could not write %s. Add this line to your shell profile:\n %s\n' "$profile" "$path_line"
  142. exit 0
  143. fi
  144. printf 'Open a new terminal, then run skilld --version.\n'

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.