Skip to content
Agent skills, managed

Every repository’s agent skills, in one place.

Keep one library of skills, give each repo the ones it needs with its own notes, and review every change before it lands. Install once and every clone has them.

For the whole team. Nothing to install for people who only use the skills.

A skill library patched into three repositories: each repository gets its own set of skills, two are current and one is behind.
One library, patched into every repo. A lit lamp means the repo is current.

Skills live in the repo, where agents look for them.

Skillify writes plain files: SKILL.md folders and an AGENTS.md block. No plugin, no runtime, nothing to sign in to when you clone.

Read by

  • Claude Code
  • Codex
  • Cursor
  • Copilot
  • any agent that reads AGENTS.md

Skills are easy to write. Keeping twenty repos straight is not.

It starts with one good skill copied into a few repos. A quarter later nobody knows which copy is right.

  • The review skill was copied into twelve repos last spring. Now there are twelve review skills.

    One library. Repos get the shared skill and update with a single sync.

  • Nobody can say which repo has which version, or whether anyone touched it.

    Each repo reports what is on disk. Lamps show current, behind or edited locally.

  • Payments needs one extra rule, so payments forked the skill and never came back.

    Skills are built in layers: the shared text, your team’s additions, then notes for one repo. Every layer keeps updating.

  • An agent “improved” the team’s standards in a PR nobody read closely.

    Agents can only propose. A teammate who is not the author reviews the diff and approves it.

  • Thirty skills installed, and no idea which ones agents ever load.

    An opt-in hook counts uses per skill and repo. Counts only, nothing from the session.

  • Every skill’s description sits in every session’s context, used or not.

    See each repo’s context cost next to its usage, and drop what nobody uses.

Three ways to have a skill.

Whichever way a skill arrives, it reaches a repo the same way: built in layers, so each part has one owner and keeps updating.

tdd · acme/payments-api

The imported tdd skill as installed in payments-api, in three layers: the upstream text from mattpocock/skills, the team's additions under Our additions, and a note only this repo gets under In this repository.

How it works.

Four steps. After the first install, the only command anyone runs is sync.

  1. Collect skills three ways.

    Import from GitHub and use as-is or add your team’s notes, write team skills for any repo, or write one for a single repo. Every edit is a new version.

    Skills

    The skill library with all three kinds of skill: review, a team skill that is global and required; tdd, imported from mattpocock/skills with the team's additions and an update available; ledger-rules, written for payments-api only; and grill-me, imported and used as-is.

  2. Give each repo its skills, tailored.

    Global skills reach every repo on their own. Add the rest one by one or as a kit, then an overlay for what only this repo needs.

    acme/payments-api · Skills

    The skills of payments-api: review arrives as a required global skill, tdd was added with an overlay, grill-me is pinned to version 1, ledger-rules was written for this repo, and the global design-tokens skill is opted out.

  3. Install once and commit. Every clone has them.

    One line from the repo’s Install tab writes the skills, the AGENTS.md block and a small CLI. After that, sync.

    Terminal
    curl -fsSL https://skillify.yogan.dev/i/in_7Hq2…Xc | sh
    Skillify · acme/payments-api
    ✓ 6 skills → .agents/skills, .claude/skills
    ✓ AGENTS.md: skills block added (your text untouched)
    ✓ CLAUDE.md: created with @AGENTS.md
    ✓ .skillify/config.json, lock.json, cli.mjs
    git add -A && git commit -m "Add agent skills"
    # a week later, after review v6 is approved
    node .skillify/cli.mjs sync
    ✓ review v5 → v6
    5 skills already current
    
  4. Change a skill by proposal, never in place.

    Anyone, or any agent, can propose an edit. A teammate approves it, it becomes the next version, and every repo picks it up on sync.

    Proposal #14 · review

    Proposal 14, sent by an agent over MCP: it adds a step to the review skill asking the agent to check migrations. It waits for a teammate who is not the author to approve it.

What you get.

Shown on a made-up team, acme.

See every repo at a glance

Each sync reports what is on disk. A repo that is behind, or edited by hand, shows up before anyone wonders why its agent acts differently.

Repositories in the docs
Repositories

Four repositories: storefront is current, payments-api is one skill behind, design-system has a locally edited skill, and docs-site has not reported yet.

Know what gets used

Uses per skill and repo over time, from an opt-in hook. Next to it, what each skill costs in context.

Usage in the docs
Usage · last 30 days

Skill uses across all repositories in the last 30 days: review leads with 412, tdd 268, diagnose 131, triage-issue 44, and write-a-prd was not used at all.

A check for CI

status --check fails the build when a repo falls behind or someone edits a skill in place.

The CI check
CI
node .skillify/cli.mjs status --check
✓ tdd, grill-me, diagnose: current
! review: behind (v5, latest v6)
✗ triage-issue: edited locally
Run sync, or propose your edit. Exit 1.

Agents can ask for skills

An MCP server lets agents browse the library, add skills to a repo and propose edits. They can never approve one.

The MCP server
Claude Code
claude mcp add --transport http skillify https://skillify.yogan.dev/mcp --header "Authorization: Bearer $SKILLIFY_TOKEN"
# then, in a session: “add the review skill to this repo and tell it we use pnpm”
✓ add_skill_to_repo review → acme/storefront
✓ set_repo_overlay review: “Use pnpm, never npm.”
Run node .skillify/cli.mjs sync to write it.

AGENTS.md, kept in step

Sync writes a table of the repo’s skills and its conventions between two markers. The rest of the file stays yours.

What gets written
AGENTS.md
<!-- skillify:start -->
## Agent skills

| Skill | Use when |
| --- | --- |
| [review](.agents/skills/review/SKILL.md) | Reviewing a pull request |
| [tdd](.agents/skills/tdd/SKILL.md) | Building a feature test-first |

### Repository conventions

Money is integer cents. Webhooks are idempotent.
<!-- skillify:end -->

Fair questions.

  • Does everyone on the team need an account?

    No. Skills are committed to the repo, so a fresh clone already has them. Accounts are for the people who manage skills, assign them and review changes.

  • Which agents does it work with?

    Anything that reads skills from .claude/skills or .agents/skills, or follows AGENTS.md: Claude Code, Codex, Cursor, Copilot and others. Pick the targets per repo.

  • What happens if someone edits a skill inside a repo?

    Sync will not overwrite it. It names the file and offers two ways out: turn the edit into a proposal so every repo gets it, or drop it with --force. CI can catch it first with status --check.

  • We import skills from GitHub. Do we lose upstream changes if we add to them?

    No. Your team’s additions sit in their own “Our additions” section and are carried onto every re-import, so upstream changes keep flowing. Skillify checks sources daily and shows the diff before anything changes. For deeper changes, fork it into a team skill and Skillify keeps showing what changed in the original.

  • What does usage tracking send?

    The repo, the skill’s name and the time, with a write-only key that cannot read anything. Never prompts, code or file contents. Turn it off with "usage": false in .skillify/config.json.

  • Can an agent change our standards?

    It can suggest a change. Every proposal waits for a person who is not its author, who sees the diff and the lint results before approving.

Start with one repo.

Sign in with your work email, import a skill source, add a repo and run the line from its Install tab. About five minutes.

Later, in any reposhell
node .skillify/cli.mjs sync

That is the whole routine: sync when the library changes, commit what it writes.