csk: a skills manager for Claude Code, built 100% with Claude Code

Yesterday I released the first usable version of a small and slightly recursive project: csk, a skills manager for Claude Code. The recursive part is that I didn’t write a single line of code by hand. csk is built, from start to finish, with Claude Code. A tool for Claude Code, built by Claude Code. A snake biting its own tail, but a snake that compiles.

I want to tell you what problem it solves — because you probably have it and haven’t put a name to it yet — and leave you the path to try it in five minutes.

The problem: skills without a skeleton

If you use Claude Code, you know that a skill is a folder with instructions that teaches it to do something specific: a workflow, a format, a quirk of yours. Claude Code has two ways to load them. Plugins are distributed through a marketplace, installed with a command and updated on their own. And then there are personal skills: loose folders in ~/.claude/skills/.

Here’s the crack. Plugins have a carefully crafted distribution story. Personal skills have none. If you develop a skill in its own git repository, the workflow is artisanal and a bit sad: clone by hand, copy or link it inside ~/.claude/skills/, and remember — you, with your primate memory — to run git pull every so often. There’s no manifest. There’s no lockfile. There’s no way to declare "this is my set of skills" and reproduce it on another machine or hand it to a colleague.

Think about it in terms of biomechanics. A plugin is a prosthesis that comes with its own fitting service: it fits, it’s calibrated, it’s checked. A personal skill is a prosthesis you carry loose in your backpack and strap on however you can each morning. It works, sure. But there’s no connective tissue: nothing holding the set together, nothing guaranteeing that today’s arm is the same as yesterday’s.

And the side effect is the worst of all: drift. You work on the laptop, on the tower at home, on the one at the office. Each machine accumulates its own versions, its own patches, its own lapses. After a few months you don’t have one environment replicated three times: you have three different subspecies of the same organism, evolving separately and in silence. The day one fails and another doesn’t, you have no idea why.

What csk is

csk fills exactly that crack. The idea is to steal the mental model from tools that already work: what cargo or uv are to libraries, csk is to skills. Three pieces, and the metaphor falls into place on its own:

The manifest (skills.toml) is the DNA. You edit it. You declare each skill with a key, a git URL and, if you want, a branch or a subdirectory. It’s the intent: "this organism should have these organs".

The lockfile (skills.lock) is the pinned expression of that DNA. csk writes it, not you, and it anchors each skill to an exact commit. It’s the difference between "I want a dog" and "I want this dog, with this genome, down to the last base pair".

csk install is the cloning. On a fresh machine, csk reads the lockfile and rebuilds the identical set: same skills, same commits nailed down. The same organism, not a distant cousin.

The elegant thing is that csk doesn’t touch Claude Code at all. It writes to the same ~/.claude/skills/ paths Claude already reads. Claude Code doesn’t need to know csk exists. Zero coupling.

Try it in five minutes

csk is a single static binary, written in Go. On macOS or Linux you install it like this (the README has the Windows version with PowerShell):

mkdir -p ~/.local/bin
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m); case "$ARCH" in x86_64|amd64) ARCH=x86_64;; aarch64|arm64) ARCH=arm64;; esac
VERSION=$(curl -sI https://github.com/pformoso-deus-ai/csk/releases/latest | awk -F/ '/^location:/ {print $NF}' | tr -d '[:cntrl:]')
curl -fsSL "https://github.com/pformoso-deus-ai/csk/releases/download/${VERSION}/csk_${VERSION#v}_${OS}_${ARCH}.tar.gz" | tar xz -C ~/.local/bin csk
chmod +x ~/.local/bin/csk

From there, the day-to-day flow:

csk init                 # creates the empty manifest and lockfile
csk search handoff       # searches the public registry (Skill Central)
csk add handoff          # installs a skill by its short name
csk list                 # see what you have and the state of each thing

You can also install directly from any git URL, without going through the registry:

csk add https://github.com/pformoso-deus-ai/handoff-claude-skill.git

And here’s the moment that justifies the whole invention. You commit your two files — skills.toml and skills.lock — alongside your dotfiles. On the next machine, after cloning them:

csk install

Same set of skills, same commits, no drift. The difference between remembering and not having to remember. If you prefer a per-project set rather than a global one, the same commands inside the project folder create a local .claude/skills.toml; csk detects the scope on its own.

There’s more in the box — csk update to refresh versions, csk adopt to register a skill you already had installed by hand without losing anything, csk doctor to diagnose drift before it hurts, csk upgrade so the binary itself updates — but with those four commands you already have 90% of the value.

The recursive part

I’ll go back to the start, because it’s what interests me most about this experiment. csk came out of a conversation: a spec written alongside Claude Code, discussed, trimmed, and then implemented in Go by Claude Code itself. Fourteen commits, four releases, from idea to a binary that works on three operating systems. I played architect and critic; the model handled the keyboard.

And that opens a door with a slightly dystopian edge that I don’t feel like dodging. As the agent becomes your main work interface, your skills stop being a configuration detail: they are, literally, your augmented body. They’re what you know how to do through the machine. And right now that body has no version control. Each laptop is a different graft, each update an unregistered patch, and nobody — not even you — knows exactly what your own environment is made of.

csk is, at its core, a modest attempt to put a skeleton on that. A manifest that says "this is what I am" and a lockfile that proves it. Because if we’re going to delegate more and more of our capability to these tools, the least we can do is know — and be able to reproduce — what they’re made of.

The project is open source, MIT-licensed, and it’s here: github.com/pformoso-deus-ai/csk. If you try it, a star and, above all, your feedback in the issues would make my day.

---

Sources and links: csk repository on GitHub · Claude Code skills documentation