Never touch your repo

The core principle of SkillHub is simple: everything written locally is gitignored by default. Working inside a client-owned repository never adds stageable files, so git status stays clean. You get your skills without leaving a trace in someone else's codebase.

Gitignored by default

When you bootstrap a project, skillhub init writes a managed .gitignore block — a delimited section with marker comments — covering the project config directory and every agent skills directory it links into. Because the block is delimited, it's easy to keep updated and easy to remove.

You can opt out with --no-gitignore, but the default keeps the guarantee intact:

skillhub init
skillhub init --no-gitignore

It keeps up with new agents

A later fan-out can reach an agent directory that did not exist at bootstrap — you installed a new coding agent, or a teammate's config named one. When that happens, skillhub install, skillhub sync, skillhub update, and skillhub remove extend the managed block to cover the new directory, so the guarantee covers agents added at any point, not just the ones present when you ran skillhub init.

The extension is strictly additive — nothing already inside the block is removed, reordered, or reformatted, so a hand-added entry or a comment you wrote survives it byte for byte. And it never creates a block: if there is no .gitignore, no managed markers, or damaged ones, the file is left exactly as found. That is what keeps an --no-gitignore decision honoured by every one of those commands. (skillhub init itself is the exception, and deliberately so — writing the block is what it's for, so re-running it without --no-gitignore writes one.) Each command reports the outcome as gitignore in its --json payload.

One store, many agents

Skills install once into a canonical local store, then fan out by symlink into each detected agent's skills directory:

• project scope — the store lives in the project config directory, .skillhub/ at the repo root (its skills/ subfolder).
• global scope — the store lives under your home directory (its skills/ subfolder).

A single install, symlinked into every agent, means every coding agent on the machine sees the same skill without duplicated copies.

Copying is the fallback, never the default. Pass --copy to force it, and on platforms without symlink support the CLI auto-falls-back to copy with a notice.

skillhub install @studio/design-systems/tokens-workflow
skillhub install @studio/design-systems/tokens-workflow --copy

The store is also where you edit an installed skill. Each install records a content baseline for the directory it wrote, so the CLI can tell a skill that is still what it shipped from one carrying your changes: a modified skill is never replaced or deleted without an explicit decision, skillhub list shows it as modified, and a run that would destroy it refuses with STORE_MODIFIED. The same does not hold for a copy in an agent skills directory — those are rebuilt from the store on every sync. See Skills you've edited in the store.

Invisibility

Access isn't just restricted — it's invisible. A limited outsider sees only the registries they've been granted. Other registries, org pages, and out-of-grant search results don't appear as "forbidden"; they simply aren't there. What you can't reach, you can't see.

Keeping the guarantee intact

skillhub doctor verifies the pieces that make this work: the integrity of the managed gitignore block, the health of every symlink, and whether the lockfile matches what's on disk:

skillhub doctor
skillhub doctor --global

If anything drifts, doctor reports it with a suggested fix so the never-touch-your-repo promise stays true.