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

The Library Meta-Skill: Distributing Private Agentic Tooling at Scale

The Core Problem

As engineers scale from using a single coding agent to running multiple specialized agents across many codebases, a coordination problem emerges. Skills, agents, and prompts get duplicated, go out of sync, and become impossible to manage. If you work on 10+ repositories and build private, specialized agentic tooling, you need a system for distributing that tooling consistently.

The problem is not relevant for engineers working on one or two repositories where everything stays local. It becomes critical when you operate across many codebases, multiple devices, and team members who each run their own agents.

The Solution: A Meta-Skill Called "The Library"

The library is a meta-skill: a skill that unlocks and distributes other skills, agents, and prompts. It consists of two core components:

• A YAML reference file that stores pointers (not copies) to skills, agents, and prompts located in Git repositories or local file paths
• A skill file (skills.md) that provides the commands for managing the library

This is a purely agentic application. There is no traditional code involved. The entire system runs through a skill that an agent executes. Think of the YAML file like a package.json or pyproject.toml, but for your agentic tooling rather than code dependencies.

The Agentic Engineering Stack

IndyDevDan organizes agentic engineering into three layers, each serving a distinct purpose:

• Skills: Raw capabilities. These are the building blocks that perform specific tasks.
• Agents: Provide scale and parallelism. They execute skills and can operate autonomously.
• Prompts: Orchestrate the layers below. Single-file prompts coordinate how skills and agents work together.

Many engineers make the mistake of overloading skills with too much logic. Instead, you should distribute responsibility across all three layers.

The Library API and Workflow

The workflow follows four stages: Build, Catalog, Distribute, Use.

1. Build your skills, agents, and prompts inside whatever repository generates value
2. Catalog them by running /library add to create references in the YAML file
3. Distribute by syncing the library to other devices, agents, or team members
4. Use them anywhere by running /library use to pull referenced items into a local or global directory

Additional commands include list (show all references), search (find specific items), push (send updates back to the source repo), and sync (pull the latest versions of all referenced codebases).

Private Distribution Matters

A key emphasis throughout the video is that specialized, high-value agentic tooling should remain private. The library system supports private Git repositories as the primary reference source, keeping proprietary skills, agents, and prompts secure while still making them accessible to authorized devices and team members.

Public repositories and local file paths are also supported as reference sources, but the private distribution use case is the primary motivation.

Cross-Device Syncing Demo

The video demonstrates syncing skills between a primary development machine and a Mac Mini running as a dedicated agent device. The process is straightforward:

1. Clone the library repository into the global .claude/skills/ directory on the target device
2. Run /library use meta-* install globally to pull referenced skills into the global namespace
3. The agent device now has access to the same meta-agentics as the primary machine

This same pattern works for cloud sandboxes, teammate machines, or any environment with Git access to your private repositories.

Updating and Pushing Changes

When a skill gets updated on any device, the /library push command sends changes back to the source repository. This maintains the single source of truth. The video shows updating a meta-prompt's output format from YAML to table format on the Mac Mini, then pushing that change back to the private GitHub repository where it becomes available to all other devices on next sync.

Meta-Agentics: Skills That Build Skills

The video highlights four "meta-agentic" skills that are especially important to distribute widely:

• Meta Prompt: A skill for building prompts in a structured, templated format
• Meta Skill: A skill for building new skills
• Meta Agent: A skill for building agents
• Meta Prime: A foundational coordination skill

These are the tools that accelerate your ability to create new agentic tooling. Distributing them globally ensures consistent quality and structure across everything you build.

Key Takeaways

• The library is a reference system, not a storage system. It points to repositories rather than duplicating code.
• A purely agentic application can replace traditional tooling. The entire library runs as a skill with no compiled code.
• Trust in your agents comes from knowing exactly what they run. Build and own your skills rather than relying solely on public plugins.
• The agentic evolution path goes: base agent, better agent, more agents, custom agents, orchestrator agents, then agents with dedicated devices. At each stage, the need for organized distribution grows.
• The cookbook pattern (organizing individual agentic workflows within a skill) keeps complex skills readable for both humans and agents.