Skip to content
Back to search

the-library

A Meta-Skill for Private-First Distribution of Agentics (Skills, Agents, and Prompts) across your Agents, Devices, and Teams.

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/disler--the-library/badge.svg)](/listings/disler--the-library)

HTML

<a href="/listings/disler--the-library"><img src="/api/listings/disler--the-library/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.

This is a template repo. You fork it, clone it into your global skills directory, and it becomes a `/library` slash command available in every Claude Code session.

1. Fork This Repo

Fork to your own GitHub account (private repo recommended). This fork is your personal library catalog — you'll push catalog updates to it.

# Using GitHub CLI
gh repo fork disler/the-library --private --clone=false

Or fork manually via the GitHub UI.

2. Clone to Global Skills Directory

Clone your fork into `~/.claude/skills/library`. This path is what makes `/library` available as a global slash command in Claude Code.

# Using git
mkdir -p ~/.claude/skills/library
git clone <your-fork-url> ~/.claude/skills/library

# Or using GitHub CLI
gh repo clone <yourname>/the-library ~/.claude/skills/library

3. Configure

Open `~/.claude/skills/library/SKILL.md` and update the `## Variables` section with your fork URL. The agent reads these variables at runtime to know where to sync the catalog.

# Before (template defaults)
- **LIBRARY_REPO_URL**: `<your forked repo url>`

# After (your values)
- **LIBRARY_REPO_URL**: `https://github.com/yourname/the-library.git`

The other two variables (`LIBRARY_YAML_PATH` and `LIBRARY_SKILL_DIR`) are correct by default if you cloned to `~/.claude/skills/library/`.

4. Verify

Start a new Claude Code session anywhere. `/library list` should work and show an empty catalog.

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.

SKILL.md · Manifest · 190 lines

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

  1. ---
  2. name: library
  3. description: Private skill distribution system. Use when the user wants to install, use, add, push, remove, sync, list, or search for skills, agents, or prompts from their private library catalog. Triggers on /library commands or mentions of library, skill distribution, or agentic management.
  4. argument-hint: [command or prompt] [name or details]
  5. ---
  6. # The Library
  7. A meta-skill for private-first distribution of agentics (skills, agents, and prompts) across agents, devices, and teams.
  8. ## Variables
  9. > Update these after forking and cloning the library repo.
  10. - **LIBRARY_REPO_URL**: `<your forked repo url>`
  11. - **LIBRARY_YAML_PATH**: `~/.claude/skills/library/library.yaml`
  12. - **LIBRARY_SKILL_DIR**: `~/.claude/skills/library/`
  13. ## How It Works
  14. The Library is a catalog of references to your agentics. The `library.yaml` file points to where skills, agents, and prompts live (local filesystem or GitHub repos). Nothing is fetched until you ask for it.
  15. **The `library.yaml` is a catalog, not a manifest.** Entries define what's *available* — not what gets installed. You pull specific items on demand with `/library use <name>`.
  16. ## Commands
  17. | Command | Purpose |
  18. | --------------------------- | ---------------------------------------- |
  19. | `/library install` | First-time setup: fork, clone, configure |
  20. | `/library add <details>` | Register a new entry in the catalog |
  21. | `/library use <name>` | Pull from source (install or refresh) |
  22. | `/library push <name>` | Push local changes back to source |
  23. | `/library remove <name>` | Remove from catalog and optionally local |
  24. | `/library list` | Show full catalog with install status |
  25. | `/library sync` | Re-pull all installed items from source |
  26. | `/library search <keyword>` | Find entries by keyword |
  27. ## Cookbook
  28. Each command has a detailed step-by-step guide. **Read the relevant cookbook file before executing a command.**
  29. | Command | Cookbook | Use When |
  30. | ------- | --------------------------------------- | ----------------------------------------------------------- |
  31. | install | [cookbook/install.md](cookbook/install.md) | First-time setup on a new device |
  32. | add | [cookbook/add.md](cookbook/add.md) | User wants to register a new skill/agent/prompt in catalog |
  33. | use | [cookbook/use.md](cookbook/use.md) | User wants to pull or refresh a skill from the catalog |
  34. | push | [cookbook/push.md](cookbook/push.md) | User improved a skill locally and wants to update the source |
  35. | remove | [cookbook/remove.md](cookbook/remove.md) | User wants to remove an entry from the catalog |
  36. | list | [cookbook/list.md](cookbook/list.md) | User wants to see what's available and what's installed |
  37. | sync | [cookbook/sync.md](cookbook/sync.md) | User wants to refresh all installed items at once |
  38. | search | [cookbook/search.md](cookbook/search.md) | User is looking for a skill but doesn't know the exact name |
  39. **When a user invokes a `/library` command, read the matching cookbook file first, then execute the steps.**
  40. ## Source Format
  41. The `source` field in `library.yaml` supports these formats (auto-detected):
  42. - `/absolute/path/to/SKILL.md` — local filesystem
  43. - `https://github.com/org/repo/blob/main/path/to/SKILL.md` — GitHub browser URL
  44. - `https://raw.githubusercontent.com/org/repo/main/path/to/SKILL.md` — GitHub raw URL
  45. Both GitHub URL formats are supported. Parse org, repo, branch, and file path from the URL structure. For private repos, use SSH or `GITHUB_TOKEN` for auth automatically.
  46. **Important:** The source points to a specific file (SKILL.md, AGENT.md, or prompt file). We always pull the entire parent directory, not just the file.
  47. ## Source Parsing Rules
  48. **Local paths** start with `/` or `~`:
  49. - Use the path directly. Copy the parent directory of the referenced file.
  50. **GitHub browser URLs** match `https://github.com/<org>/<repo>/blob/<branch>/<path>`:
  51. - Parse: `org`, `repo`, `branch`, `file_path`
  52. - Clone URL: `https://github.com/<org>/<repo>.git`
  53. - File location within repo: `<path>`
  54. **GitHub raw URLs** match `https://raw.githubusercontent.com/<org>/<repo>/<branch>/<path>`:
  55. - Parse: `org`, `repo`, `branch`, `file_path`
  56. - Clone URL: `https://github.com/<org>/<repo>.git`
  57. - File location within repo: `<path>`
  58. ## GitHub Workflow
  59. When working with GitHub sources, prefer `gh api` for accessing single files (e.g., reading a SKILL.md to check metadata). For pulling entire skill directories, clone into a temp dir per the steps below.
  60. **Fetching (use):**
  61. 1. Clone the repo with `git clone --depth 1 <clone_url>` into a temporary directory
  62. 2. Navigate to the parent directory of the referenced file
  63. 3. Copy that entire directory to the target local directory
  64. 4. The temporary directory is cleaned up automatically
  65. **Pushing (push):**
  66. 1. Clone the repo with `git clone --depth 1 <clone_url>` into a temporary directory
  67. 2. Overwrite the skill directory in the clone with the local version
  68. 3. Stage only the relevant changes: `git add <skill_directory_path>`
  69. 4. Commit with message: `library: updated <skill name> <what changed>`
  70. 5. Push to remote
  71. 6. The temporary directory is cleaned up automatically
  72. ## Typed Dependencies
  73. The `requires` field uses typed references to avoid ambiguity:
  74. - `skill:name` — references a skill in the library catalog
  75. - `agent:name` — references an agent in the library catalog
  76. - `prompt:name` — references a prompt in the library catalog
  77. When resolving dependencies: look up each reference in `library.yaml`, fetch all dependencies first (recursively), then fetch the requested item.
  78. ## Target Directories
  79. By default, items are installed to the **default** directory from `library.yaml`:
  80. ```yaml
  81. default_dirs:
  82. skills:
  83. - default: .claude/skills/
  84. - global: ~/.claude/skills/
  85. agents:
  86. - default: .claude/agents/
  87. - global: ~/.claude/agents/
  88. prompts:
  89. - default: .claude/commands/
  90. - global: ~/.claude/commands/
  91. ```
  92. - If the user says "global" or "globally", use the `global` directory.
  93. - If the user specifies a custom path, use that path.
  94. - Otherwise, use the `default` directory.
  95. ## Library Repo Sync
  96. The library skill itself lives in `<LIBRARY_SKILL_DIR>` as a cloned git repo. When running `add` (which modifies `library.yaml`), always:
  97. 1. `git pull` in the library directory first to get latest
  98. 2. Make the changes
  99. 3. `git add library.yaml && git commit && git push`
  100. This keeps the catalog in sync across devices.
  101. ## Example Filled Library File
  102. ```yaml
  103. default_dirs:
  104. skills:
  105. - default: .claude/skills/
  106. - global: ~/.claude/skills/
  107. agents:
  108. - default: .claude/agents/
  109. - global: ~/.claude/agents/
  110. prompts:
  111. - default: .claude/prompts/
  112. - global: ~/.claude/prompts/
  113. library:
  114. skills:
  115. - name: firecrawl
  116. description: Scrape, crawl, and search websites using Firecrawl CLI
  117. source: /Users/me/projects/tools/skills/firecrawl/SKILL.md
  118. - name: meta-skill
  119. description: Creates new Agent Skills following best practices
  120. source: /Users/me/projects/tools/skills/meta-skill/SKILL.md
  121. - name: diagram-kroki
  122. description: Generate diagrams via Kroki HTTP API supporting 28+ languages
  123. source: https://github.com/myorg/private-skills/blob/main/skills/diagram-kroki/SKILL.md
  124. requires: [skill:firecrawl]
  125. - name: green-screen-captions
  126. description: Generate and burn AI-powered captions onto green screen videos
  127. source: https://raw.githubusercontent.com/myorg/video-tools/main/skills/green-screen-captions/SKILL.md
  128. requires: [agent:video-processor, prompt:caption-style]
  129. agents:
  130. - name: video-processor
  131. description: Processes video files with ffmpeg and whisper transcription
  132. source: /Users/me/projects/tools/agents/video-processor/AGENT.md
  133. - name: code-reviewer
  134. description: Reviews code for quality, security, and performance
  135. source: https://github.com/myorg/agent-configs/blob/main/agents/code-reviewer/AGENT.md
  136. prompts:
  137. - name: caption-style
  138. description: Style guide for generating video captions
  139. source: /Users/me/projects/content/prompts/caption-style.md
  140. - name: commit-message
  141. description: Standardized commit message format for all projects
  142. source: https://github.com/myorg/team-prompts/blob/main/prompts/commit-message.md
  143. ```
README.md · README · 278 lines

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

  1. # The Library
  2. A meta-skill for private-first distribution of agentics (skills, agents, and prompts) across agents, devices, and teams.
  3. ![The Library](images/10_meta_skill.svg)
  4. ## Who This Is For
  5. If you're an engineer working on 10+ codebases with agents and you're building specialized private skills, agents, and prompts — this was made for you.
  6. If you work in one or two repos, you don't need this. If you install skills from the public internet without reviewing them, this isn't for you either.
  7. The Library solves a specific problem: you've built powerful agentics scattered across repos, devices, and teams. They're duplicated, out of sync, and hard to coordinate. This gives you a single reference catalog to distribute them privately.
  8. ## What It Is
  9. The Library is a single skill whose only job is to manage other skills. It's a catalog of references — local file paths and GitHub repo URLs — that point to where your agentics live. Nothing is copied or installed until you ask for it.
  10. Think of it as a `package.json` for agent capabilities — but instead of packages, you're managing skills, agents, and prompts. Instead of a registry, you're pointing at your own private GitHub repos and local paths.
  11. **This is a pure agent application.** There are no scripts, no CLIs, no dependencies, no build tools. The entire application is encoded in `SKILL.md` and a set of cookbook instructions that teach the agent exactly what to do. The agent IS the runtime. This matters because:
  12. - Any agent harness that reads skill files can run it (Claude Code, Pi, etc.)
  13. - You can modify behavior by editing markdown, not code
  14. - The skill can be extended, forked, and adapted instantly
  15. - An orchestrator agent can chain library commands without any tooling overhead
  16. ## Why It Exists
  17. ![The Problem: Skill Sprawl](images/26_problem_skill_sprawl.svg)
  18. As you build with AI agents, you accumulate skills, custom agents, and prompts — potentially hundreds of them. You need to:
  19. - **Reuse** them across projects without copy-pasting
  20. - **Distribute** them to your agents running on other devices (Mac mini, remote servers, cloud sandboxes)
  21. - **Share** them with your team without making everything public
  22. - **Keep them private** — these are specialized capabilities built for competitive edge
  23. - **Stay in sync** — one source of truth, not 10 stale copies
  24. ![The Problem: Siloed Teams](images/32_problem_team_sharing.svg)
  25. Existing solutions don't fit:
  26. - **Global `~/.claude/*`** — exposes everything to every agent. Global is the opposite of specialized.
  27. - **Claude Code plugins** — requires marketplace infrastructure, manifests, and locks you into one platform.
  28. - **Single monorepo** — doesn't reflect reality. You build agentics in specific codebases for specific use cases.
  29. ## How It Works
  30. ![The Solution: The Library](images/27_solution_library_workflow.svg)
  31. ### The Catalog (`library.yaml`)
  32. ```yaml
  33. default_dirs:
  34. skills:
  35. - default: .claude/skills/
  36. - global: ~/.claude/skills/
  37. agents:
  38. - default: .claude/agents/
  39. - global: ~/.claude/agents/
  40. prompts:
  41. - default: .claude/commands/
  42. - global: ~/.claude/commands/
  43. library:
  44. skills:
  45. - name: my-skill
  46. description: What this skill does
  47. source: /Users/me/projects/tools/skills/my-skill/SKILL.md
  48. requires: [agent:helper-agent]
  49. - name: remote-skill
  50. description: A skill from a private repo
  51. source: https://github.com/myorg/private-skills/blob/main/skills/remote-skill/SKILL.md
  52. agents: []
  53. prompts: []
  54. ```
  55. The catalog stores pointers, not copies. Skills live in their source repos. You pull on demand.
  56. ### Source Formats
  57. | Format | Example |
  58. | ------------------ | ------------------------------------------------------------------ |
  59. | Local filesystem | `/absolute/path/to/SKILL.md` |
  60. | GitHub browser URL | `https://github.com/org/repo/blob/main/path/to/SKILL.md` |
  61. | GitHub raw URL | `https://raw.githubusercontent.com/org/repo/main/path/to/SKILL.md` |
  62. The source points to a specific file. The system pulls the entire parent directory (skills include scripts, references, assets — not just the markdown file).
  63. For private repos, authentication uses SSH keys or `GITHUB_TOKEN` automatically.
  64. ### Typed Dependencies
  65. Dependencies use typed references to avoid name collisions:
  66. ```yaml
  67. requires: [skill:base-utils, agent:reviewer, prompt:task-router]
  68. ```
  69. Dependencies are resolved and pulled first, recursively.
  70. ## Prerequisites
  71. - **Claude Code** (or a compatible agent harness that reads `.claude/skills/` — e.g., Pi)
  72. - **git** — for cloning sources and syncing the catalog
  73. - **gh** (optional) — GitHub CLI for forking, cloning, and private repo access. Install: `brew install gh` or see [gh docs](https://cli.github.com)
  74. - **GitHub SSH key or `GITHUB_TOKEN`** — for accessing private repos (not needed if using `gh auth login`)
  75. - **just** (optional) — for justfile shortcuts. Install: `brew install just` or see [just docs](https://github.com/casey/just)
  76. ## Installation
  77. This is a template repo. You fork it, clone it into your global skills directory, and it becomes a `/library` slash command available in every Claude Code session.
  78. ### 1. Fork This Repo
  79. Fork to your own GitHub account (private repo recommended). This fork is your personal library catalog — you'll push catalog updates to it.
  80. ```bash
  81. # Using GitHub CLI
  82. gh repo fork disler/the-library --private --clone=false
  83. ```
  84. Or fork manually via the GitHub UI.
  85. ### 2. Clone to Global Skills Directory
  86. Clone your fork into `~/.claude/skills/library`. This path is what makes `/library` available as a global slash command in Claude Code.
  87. ```bash
  88. # Using git
  89. mkdir -p ~/.claude/skills/library
  90. git clone <your-fork-url> ~/.claude/skills/library
  91. # Or using GitHub CLI
  92. gh repo clone <yourname>/the-library ~/.claude/skills/library
  93. ```
  94. ### 3. Configure
  95. Open `~/.claude/skills/library/SKILL.md` and update the `## Variables` section with your fork URL. The agent reads these variables at runtime to know where to sync the catalog.
  96. ```markdown
  97. # Before (template defaults)
  98. - **LIBRARY_REPO_URL**: `<your forked repo url>`
  99. # After (your values)
  100. - **LIBRARY_REPO_URL**: `https://github.com/yourname/the-library.git`
  101. ```
  102. The other two variables (`LIBRARY_YAML_PATH` and `LIBRARY_SKILL_DIR`) are correct by default if you cloned to `~/.claude/skills/library/`.
  103. ### 4. Verify
  104. Start a new Claude Code session anywhere. `/library list` should work and show an empty catalog.
  105. ## Quick Start
  106. ![Full Workflow](images/45_solution_full_workflow.svg)
  107. Here's the typical workflow: **build → catalog → distribute → use**.
  108. ### Add a skill to the catalog
  109. You built a deploy skill in one of your repos. Register it:
  110. ```
  111. /library add deploy skill from https://github.com/yourorg/infra-tools/blob/main/skills/deploy/SKILL.md
  112. ```
  113. This adds a reference to `library.yaml` and pushes the update to your fork.
  114. ### Use it in another project
  115. On another device, repo, or agent:
  116. ```
  117. /library use deploy
  118. ```
  119. This pulls the skill from the source repo into `.claude/skills/deploy/`.
  120. Want it globally available on this machine?
  121. ```
  122. /library use deploy install globally
  123. ```
  124. ### Push changes back
  125. You improved the skill locally. Push the update to the source repo:
  126. ```
  127. /library push deploy
  128. ```
  129. Now every device that runs `/library sync` gets the latest version.
  130. ### Sync everything
  131. Pull the latest version of all installed items:
  132. ```
  133. /library sync
  134. ```
  135. ## Commands
  136. | Command | What It Does |
  137. | --------------------------- | ---------------------------------------------------------- |
  138. | `/library install` | First-time setup — fork, clone, configure |
  139. | `/library add <details>` | Register a new entry in the catalog |
  140. | `/library use <name>` | Pull from source into local directory (install or refresh) |
  141. | `/library push <name>` | Push local changes back to the source |
  142. | `/library remove <name>` | Remove from catalog and optionally delete local copy |
  143. | `/library list` | Show full catalog with install status |
  144. | `/library sync` | Re-pull all installed items from source |
  145. | `/library search <keyword>` | Find entries by name or description |
  146. ### Justfile Shortcuts
  147. The included `justfile` lets you run library commands from your terminal without an interactive Claude session.
  148. ```bash
  149. just list # List catalog
  150. just use my-skill # Pull a skill
  151. just push my-skill # Push changes back
  152. just add "name: foo, description: bar, source: /path/to/SKILL.md"
  153. just sync # Re-pull all installed items
  154. just search "keyword"
  155. ```
  156. > **Note:** Justfile recipes use `--dangerously-skip-permissions` because the agent needs filesystem and git access to clone, copy, and push. Review the `justfile` if you want to modify this behavior.
  157. ## Architecture
  158. ```
  159. ~/.claude/skills/library/ # The Library skill (globally installed)
  160. SKILL.md # Agent instructions — the brain
  161. library.yaml # Your catalog of references
  162. cookbook/ # Step-by-step guides for each command
  163. install.md
  164. add.md
  165. use.md
  166. push.md
  167. remove.md
  168. list.md
  169. sync.md
  170. search.md
  171. justfile # CLI shorthand for all commands
  172. README.md # This file
  173. ```
  174. ## Design Principles
  175. - **Private-first**: Built for your specialized, competitive-edge agentics. Not a public marketplace.
  176. - **Reference-based**: The catalog stores pointers, not copies. Skills live in their source repos.
  177. - **Pure agent**: No scripts, no build tools. The SKILL.md teaches the agent everything it needs to know.
  178. - **Agent-agnostic**: Default target is `.claude/skills/` but supports any directory for any agent harness.
  179. - **Catalog, not manifest**: Entries define what's available, not what's installed. Pull on demand.
  180. ## The Agentic Stack
  181. ![The Agentic Stack](images/03_agentic_stack.svg)
  182. | Layer | Purpose |
  183. | --------------- | ---------------------------------------------- |
  184. | **Skills** | Raw capabilities — what an agent can do |
  185. | **Agents** | Scale + parallelism + specialization |
  186. | **Prompts** | Orchestration — coordinate skills and agents |
  187. | **Justfile** | Terminal access without an interactive session |
  188. | **The Library** | Distribution across devices, teams, and agents |
  189. ## Master Agentic Coding
  190. > Prepare for the future of software engineering
  191. Agentic Engineering is a NEW SKILL for software engineers. And soon it will be a required skill for software engineers. Master it before the masses with [Tactical Agentic Coding](https://agenticengineer.com/tactical-agentic-coding?y=tlibms)
  192. Follow the [IndyDevDan YouTube channel](https://www.youtube.com/@indydevdan) to improve your agentic coding advantage.

Ratings and comments

Sign in to rate this skill.

Sign in

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