Skills sprawl is a dotfile problem: Chops, reviewed

Agent skills — the markdown instruction files that teach a coding agent how you want things done — have quietly become real infrastructure. Claude Code keeps them in ~/.claude/skills/, Cursor in ~/.cursor/skills/, Codex in ~/.codex/skills/, Amp in ~/.config/amp/skills/, and there’s now a cross-tool convention forming around ~/.agents/skills/. Use more than one agent, as most of us now do, and your hard-won procedures are smeared across five hidden directories in two different file formats, with no way to find the one you wrote last March.

Chops is a free, open-source macOS app by Shpigford that treats this as what it actually is: a dotfile management problem. One window, every tool’s skills and agents, and an editor. It’s a small app doing an unglamorous job, which is exactly why it works.

What it does

• Discovery across tools — scans the skills and agents directories for Claude Code, Cursor, Codex, Windsurf, Copilot, Aider, and Amp, plus any custom paths you point it at.
• A real editor — monospaced, Cmd+S to save, frontmatter parsed and displayed, so you’re editing the file where it lives instead of round-tripping through a terminal.
• Full-text search — across names, descriptions, and body content. Six months in, this is the feature you’ll open the app for.
• Collections — group skills into logical sets without moving or rewriting the source files. Non-destructive by design.
• Per-tool boilerplate — creating a new skill generates the correct skeleton for whichever agent it targets, frontmatter included.
• File watching — FSEvents-based, so edits made outside the app show up instantly.
• Registries and remotes — browse and install from the skills.sh registry, and connect to remote servers running OpenClaw or Hermes to discover and install skills living on other machines.

The feature that matters most is the symlink

Buried in the README is the detail that makes Chops more than a file browser: skills are identified by their resolved symlink path. Symlink the same file into multiple tools’ directories and Chops shows it once, badged for each tool it serves. That’s not a dedup gimmick — it’s the correct architecture for this problem, and it’s the part you should steal even if you never install the app:

git clone git@github.com:you/agent-skills.git ~/agent-skills
for tool in claude codex cursor; do
  mkdir -p ~/.${tool}/skills
  ln -s ~/agent-skills/release-checklist ~/.${tool}/skills/release-checklist
done

One canonical copy in a git repository, one symlink per tool. Edit the skill once, every agent sees the update, and your procedures get a changelog for free. The honest caveat: agents don’t all accept identical skill formats — Cursor uses .mdc files, others use markdown with frontmatter — so some skills will need thin per-tool wrappers. That’s still vastly better than five divergent copies edited by hand.

An ops-flavoured review

What I like: it reads files where they are instead of importing them into its own database-shaped world, the collections never touch source, and the search is fast. What you should know before granting it access: Chops deliberately ships with the macOS sandbox disabled, because reading dotfiles across your home directory is the entire job. Defensible, but understand you’re handing an app unsandboxed filesystem access — fetch it from the GitHub releases page, not from a mirror. And it’s a young project with no automated test suite; validate what you care about manually, the way the README says the author does.

If you’re on Linux, there’s no app for you here. But the durable lesson isn’t the app, it’s the map: skills are plain files in known directories, they dedupe cleanly through symlinks, and they belong in git. A ten-line shell script gets you the same architecture Chops renders in SwiftUI.

Version your procedures like code

A skill is an instruction sheet an agent will follow with real tools on real systems. You wouldn’t ship an unreviewed deploy script to production, so don’t ship an unreviewed skill to the agent that can run your deploy script. Put them in a repo, review them in pull requests, and let Chops — or your symlinks — handle distribution across whichever agents you’re running this month.

The people getting real leverage from agents aren’t the ones with the best prompts. They’re the ones whose accumulated procedures survive every tool switch. Skills on disk, in git, deduplicated: that’s how that happens.