video youtu.be Watch ↗

The Library Meta-Skill: How I Distribute Private Skills, Agents and Prompts

TL;DR

Once you run agents across 10+ codebases, several devices, teammates, and agent fleets, your private prompts/agents/skills — IndyDevDan's umbrella term is "agentics" — get copied, drift, and fall out of sync. His fix is a meta skill that unlocks other skills, agents, and prompts, "the library," backed by a single YAML reference file that works like a package.json for your agentics. The load-bearing design choice is that the manifest stores references, not copies — pointers to private GitHub repos or local paths — so there is one source of truth that every device/agent/teammate syncs to. A package-manager-shaped command surface operates it: add (catalog a reference), use (install by reference into a local or global namespace), push (write a local edit back to the source repo), list/search, and sync (pull the latest source, not just the catalog); there is deliberately no versioning — internally you always want latest. The whole tool is a pure-agent application (only SKILL.md + library.yaml, no code), so an agent can run the entire build → catalog → distribute → use loop itself. This is not a new spine so much as the reuse/layered-stack cluster (Reusable Workflow Library, Layered Agentic Architecture, Meta-Prompt) extended with a concrete distribution + sync mechanism for private agentics — and it carries the 2026 trust theme: you should know exactly what your agents run, down to the lines in your skills, prompts, and agents.

Concepts introduced

Agentic Distribution — distributing private agentics (skills/agents/prompts) across devices, teams, and agents via a reference-only manifest + meta skill, with a package-manager command surface (add/use/push/list/search/sync) and a single source of truth.
Pure Agent Application — an application with no code, only agent-readable instructions (SKILL.md + library.yaml + a cookbook of named workflows); "the application is the skill," and the agent is the runtime.

Held, not dropped

The agentic maturity ladder (base → better → more → custom → orchestrator agents; agents with their own devices). A recurring IndyDevDan framing that opens and closes the talk; no dedicated page yet — hold as agentic-maturity-ladder and spin out if a second source lands on the ordering.
"Agentics" as an umbrella term (prompts + agents + skills = "the things that make your agentic system run"). Currently folded into Layered Agentic Architecture and Agentic Distribution; hold rather than mint a term-only page.
Orchestrator agents operating whole devices / domains. The scale endpoint that motivates a library; relates to Agent Supervision and Layered Agentic Architecture — held as a candidate if a source treats device-level orchestration concretely.

Key claims

Distribute agentics by reference, not by copy — one manifest of pointers, one source of truth — so copies can't drift out of sync. principle → Agentic Distribution
Below ~10 codebases / a single device this is unnecessary — "just use plugins"; the whole scheme earns its keep only at multi-codebase, multi-device, multi-agent scale. (best practice) — context: scoping who needs it; explicitly not for 1–2-repo engineers. → Agentic Distribution
Keep your top-notch specialized agentics private — distribute only the reference manifest, which can be public while the artifact repos stay private. (best practice) — context: you monetize specialized agentics. → Agentic Distribution
Give distribution a package-manager surface — add / use / push / list / search / sync — where sync pulls the actual referenced code bases and push writes local edits back to source. (best practice) — context: managing agentics at scale. → Agentic Distribution
Skip versioning for internal agentics — you almost always want the latest, so sync-to-latest beats pinned versions. (best practice) — context: one trusted owner/source; an externally published package would want versioning. → Agentic Distribution
An entire application can be a single skill with no code — the agent reads the instructions and is the runtime ("the application is the skill"). observation → Pure Agent Application
Skills = raw capability, agents = scale/parallelism, prompts = orchestration, with a task runner on top — treat them as distinct primitives instead of overkilling skills. (best practice) — context: building repeatable agent systems; corroborates the layered stack from a second source. → Layered Agentic Architecture
"Meta-agentics" are the skills that build agentics — a meta-skill that builds skills, a meta-prompt that builds prompts, a meta-agent that builds agents; author the generator once and reuse it everywhere. (best practice) — context: operators building specialized agentics at scale. → Meta-Prompt
A high-value prompt must be identical across every teammate, codebase, and device (human- and agent-operated) — which is exactly why a distributable library matters. (best practice) — context: shared engineering standards encoded as prompts. → Agentic Distribution, Meta-Prompt
Increase trust in agents by knowing exactly what they run, down to the lines in your skills, prompts, and agents — a 2026 theme. principle — durable: control/trust follows from legibility of what the agent actually executes. → Agent Supervision

Why this builds on the graph

The dominant stance is builds_on: the talk does not open a new spine so much as extend the existing reuse cluster with a concrete distribution and sync mechanism. It builds on Reusable Workflow Library — the same "agentics are durable, shareable artifacts" thesis, now with a reference-manifest + push/sync lifecycle and a payload broadened from loops to skills+agents+prompts. It corroborates Layered Agentic Architecture from a second IndyDevDan source (skills=capability / agents=scale / prompts=orchestration / justfile on top, plus the "overkilling skills" warning), and corroborates Meta-Prompt (meta-agentics as first-class reusable generators; the ~800-line meta-prompt templating his format). It introduces two genuinely new pages — Agentic Distribution (the reference-manifest-for-agentics mechanism) and Pure Agent Application (no-code, skill-as-app) — the latter also retroactively wiring Learnings from a No-Code Library: Keeping the Spec-Driven Development Triangle in Sync, its sibling one altitude up. Finally it corroborates Agent Supervision on legibility: "know exactly what your agents run" is the transparency lever applied to the agentics themselves.

Illustrated walkthrough

This talk is heavy on full-screen white-text-on-black slides. The two live demos (engineer's device, Mac mini agent) are well covered and carry the concrete detail below.

t=00:00 (f0001) — Cold open, top-down desk shot: a MacBook Pro screen-sharing to a Mac mini, both showing the green "digital tunnel" library art. Voice states the agentic ladder — "base agents → better agents → more agents → custom agents → orchestrator agents, even give your agents their own devices" — then the pain: "Where did you put that Notion CLI skill? Where did you put that Cloud Code multi-agent planning command?" Scoping caveat up front: if you work on 1–2 repos, or install public skills without review, "this video is not for you."
t≈01:12–02:00 — (text-on-black slides) The problem, stated as slides: developers deploy skills/agents/commands "all over the place"; they're endless, out of sync, duplicated, and hard to coordinate across a team — exacerbated by multiple developers each with their own agents, all copying and going stale.
t=02:01 (f0013) — Full-screen "BUT ONCE YOU START" — the turn: on a single codebase it's a non-problem, but across many codebases it becomes serious.
t≈02:05–02:40 — The solution named: "a meta skill, a skill that unlocks other skills, agents, and prompts. I'm calling this the library." Prior art cited: Stripe's "tool shed" meta-tool (previous video); here broadened to skills+agents+prompts — "one skill to unlock them all."
t≈02:48–03:20 — The stack: you stack skills, agents, prompts, and put a justfile on top. His framing — skills = raw capabilities, agents = scale/parallelism, prompts = orchestrate the two below — and the warning "a lot of people are overkilling skills, doing everything inside the skill" when other primitives exist. (This restates the Layered Agentic Architecture "Bowser" stack from a second angle.)
t≈03:24–04:00 — The package.json analogy: the library file just points to existing GitHub repos or local files; a single source of truth means you, your agents, and your co-workers "just sync and manage this one library file."
t=04:33 (f0031) — "PURE AGENTIC SOLUTIONS" slide. "This is an agent-first solution/library. It is a skill. There is no code associated with this." Prediction: "a lot of pure agentic solutions this year."
t=05:52 (f0036) — "THIS IS ABOUT PRIVATE AGENTIC DISTRIBUTION" (green emphasis). Not for the couple-codebases engineer; the point is distributing private agentics.
t≈05:55→06:30 — (max ~35 s blind gap; read from transcript) The full workflow slide — Build → Catalog (library.add) → Distribute → Use — and the API slide: the YAML supports add / use / push / list / search / sync. He stresses sync "is not just syncing your catalog, it's syncing the actual code bases to make sure you have the latest version."
t≈07:13 — (chapter "Meta Skill on Engineer's Device," 433 s) Demo begins on the Mac mini via screen sharing ("simple, very visual"; works with any cloud system as long as agents/team have access to the private Git repos). Opens the IDD library template repo he cloned; the most important file is library.yaml, holding skills / agents / prompts as references only — "not actually storing anything except the references to where these things are stored."
t≈09:55 — In a .claude-based private repo (git remote -v shows a private origin), boots Claude Code and runs /library list — prints all references in the library file and pulls the latest; the library is itself a skill + repo inside the global ~/.claude skills dir.
t≈10:41 — /library add meta-agent meta-prime meta-prompt meta-skill from <GitHub URL>: the skill loads its "add cookbook," pulls first, finds the items locally, and adds references to the YAML. He carefully distinguishes idd-library-engineering (the private repo that actually contains the reusable prompts/agents/skills) from idd-library (the reference library = the YAML + skill). "You'll have multiple of these — support, sales…"
t≈12:00 — /library use meta-* install locally into .claude/skills on his customized Pi Coding Agent (an alternative harness; running a "Sonic 6"-class Anthropic model). The skill reads the reference file and pulls the referenced skills in — "these aren't stored on my device anywhere, these are references to a repository." (Pi has damage-control: it won't run rm -rf; he tells it to skip that.) tree .claude -L2 then shows the meta-prompt/meta-skill installed with their docs/examples.
t≈13:45 — Browser: the library.yaml before/after — searching meta- shows the new entries just added. "This is a pure agent application. The application is the skill… you can encode entire applications into a single skill." (see Pure Agent Application)
t≈14:41 — Meta-agentics defined: "the skills that build the skills — the skill that builds the prompt, the skill that builds the agent." Reminder to build your own (rather than lean on Claude Code's built-in "build me a skill") so you understand them deeply.
t≈15:16 — The 2026 trust theme: "increase the trust we have in our agents… the best way is to know exactly what they're doing and running, down to the lines inside your skills, prompts, and agents." (corroborates Agent Supervision's open/plain-file legibility.)
t≈15:33 — /library use meta-* add globally (via Claude Code): installs into the global ~/.claude namespace. Notes the manifest's default dirs (skills/agents/prompts), flags a bug — Claude Code stores these under commands, not prompts — and shows the namespaces are configurable (default / global / special → arbitrary paths). Re-booting Pi in a temp dir shows 46 skills and /meta autocompleting the four meta agentics.
t=16:30 (f0091) — Terminal output table "All 4 meta- skills installed globally to ~/.claude/skills/"* — meta-agent, meta-prime, meta-prompt, meta-skill → Installed (model shown: Opus 4.6, bypass-permissions on). Behind it, the GitHub disler/idd-library repo tree: cookbook/, images/, README.md, SKILL.md, justfile, library.yaml; the visible YAML entries carry name / description / source: pointing at github.com/disler/idd-library-engineering/.../SKILL.md (alongside ruff and ty tool guides). This frame concretely shows the reference manifest structure.
t≈17:17 — (chapter "Meta Skill on Mac Mini Agent," 1037 s) On the agent device: the ~/.claude/skills dir is empty, so he clones the library repo into it, then this device can install any referenced skill. "It could be a cloud device, an agent sandbox, a teammate."
t≈18:39 — /library use meta-* install globally on the agent device → clones and installs, going from 1 → 5 global skills. (Aside plugging the Pi Coding Agent as the only real competitor to Claude Code "because it lets you customize the agent harness.")
t≈19:53 — Runs /meta prompt (his ~800-line meta-prompt, "templated my engineering into how I build my prompts") to generate a custom slash-command bash function from a one-line request (model: a "Quinn 3.5"-class model). Output carries his exact prompt format — purpose / workflow / instructions / variables. Point: "a prompt this important needs to be the exact same across all my team members, all my code bases, and all my devices, human- and agent-operated."
t≈21:40 — Update + push-back: with 10 devices using the meta skills, he edits skill.md's summary to a table format (starting on a "flashlight 3.1"-class model, then bumping up — "nothing more stable than Claude Sonnet and Opus" — to a Sonnet 4.6-class model for the write-back). /library push meta-prompt finds the global version and pushes the change back to the source repository. Chrome shows the source repo's last commit refreshing from "1 hour ago" to "just now" — the edit propagated to the single source of truth.
t=24:03 (f0129) — "PURE AGENT APPLICATION" slide. Back in .claude/skills/library: "it really only runs in skills.md and library.yaml… a purely agentic application," so an entire agent could run the whole workflow or chain pieces of it. The cookbook = individual agentic workflows the skill describes when to use, "in plain English — great for humans, great for agents," each by its exact command name.
t≈24:51 — Getting started: clone the library, you begin with a blank library.yaml, update the defaults, and start adding. "I don't care if you use my library — it's just a valuable idea if you're scaling to multiple devices, team members, and agents."
t≈25:17 — Close (chapter to 1592 s): the agentic path is base → better → more → custom → orchestrator agent; at scale the only way forward is an orchestrator that operates entire devices/systems/domains, and to reuse your agentics across all of them you want something like the library. Sign-off: "maintain your advantage in the age of agents."

(Model names above — "Sonic 6," "Quinn 3.5," "flashlight 3.1" — are caption ASR of the on-screen model pickers and may be mis-transcribed; the stable, load-bearing detail is the mechanism, not the exact model.)