Chops turns off the app sandbox so it can read every tool's dotfiles
Your AI agent skills, finally organized. A macOS app to browse, edit, and manage skills across Claude Code, Cursor, Codex, Windsurf, and Amp.
At a glance
- What is it?
- Shpigford/chops is a native macOS browser for the skill and agent files that coding agents keep in scattered dotfile directories. It has no test suite, generates its Xcode project from a specification, and deduplicates by resolved symlink.
- Who is it for?
- This suits someone whose agent configuration has spread across half a dozen tools and who wants one window over all of it, with real-time watching so a hand edit on disk shows up immediately. Two things to know first.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 84 days ago.
- What is it written in?
- Mainly Swift, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Shpigford/chops2,115 ★ · +233
| Repository | 2026-09-11 | 2026-11-15 |
|---|---|---|
| Shpigford/chops | 1.9k | 2.1k |
233 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The sandbox is disabled, and the reason is the whole product
The design decisions section lists three things and the first is the one to read twice. The application sandbox is off, the entitlements file explicitly disables it, and the stated reason is that the app needs unrestricted filesystem access to read dotfiles across your home directory, described as intentional and required for core functionality. That is an accurate self-assessment: the directories it scans are all under your home folder and several sit in places the operating system would otherwise fence off. Everything else in the app follows from that choice, including the file watcher that keeps its view current. It is also the one decision a reviewer should make explicitly, because an unsandboxed process with read access to your home directory and write access to your agent configurations is a much larger surface than a sandboxed one.
Seven tools by the feature line, five by the table
The feature list names seven tools, and the directory table below it accounts for fewer. There is a global row for a shared skills directory, then rows for five tools that have both a skills path and an agents path, and one tool, the last in the table, that has a skills path and nothing for agents. The two extra names in the feature line are explained in a single sentence underneath: they are supported but detect only project-level skills and agents, with no global paths. Custom scan paths can be added for any tool. One row is also worth reading twice because it lists two directories for the same tool and no agent path, which is the sort of detail that decides whether a given file shows up for you at all.
Identity is the resolved symlink, so one file wears several badges
Deduplication is done by resolved symlink path rather than by filename or directory. If the same file is symlinked into several of the tools' directories, it appears once in the list and carries a badge for each tool that can reach it. That is a sensible answer to a real problem, since a shared skill installed into multiple tools would otherwise appear as duplicates the user has to reconcile by hand. The same mechanism has a consequence nobody spells out: deleting or moving the underlying file changes what resolves, so a skill can vanish from a tool's view without anything being edited inside it. The list also distinguishes skills from agents, which are separate kinds of file with separate directories per tool.
The Xcode project is generated and also committed
The build instructions are unusually explicit about the project file. The project is generated from a specification file by a code generator installed through Homebrew:
git clone https://github.com/Shpigford/chops.git
cd chops
brew install xcodegen # skip if already installed
xcodegen generate # generates Chops.xcodeproj from project.ymlThe note underneath says not to edit the generated project directly and to re-run the generator if the specification changes. Yet the repository tree contains the generated project directory alongside the specification. That combination is common and workable, but a merge can produce a project file that no longer matches the specification, and the note gives no way to tell which one a given commit's binary came from. Two build routes are offered: the full graphical path of generate, open, and press the run shortcut, or a single command-line invocation that builds a debug configuration of the scheme without the editor at all.
There is no test suite, and the documentation says so twice
One of the three design decisions is that there is no test suite and that changes should be validated manually. The testing section then repeats it and gives the procedure: build and run, trigger the exact feature you changed, observe the result including any error messages, and then check the edge cases, which are named as empty states, missing directories and malformed files. Repeating a limitation this plainly is good practice. The file watcher does help in one specific sense, because a hand edit on disk re-runs the scan immediately, so you can edit a skill file in another editor and see the app react without restarting it.
Three parsers and a dispatcher pick between them
Skill files are not all the same format, and the code is organised around that. One utility parses the frontmatter format used by markdown files, a second parses the extension that one tool uses for its own rule files, and a service module decides which of the two to apply. Editing instructions point at those three files by path, which is the kind of thing that saves an afternoon. Adding a new tool is a five-step task with the same shape: add a case to the tool enumeration, fill in its display name, icon name, colour and global paths, optionally add a logo to the asset catalogue and return it from the asset-name accessor, and update the scanner only if the new tool lays its files out unusually.
macOS 15 and a code generator are the prerequisites
Four things are required to build it: the current macOS release or later, Xcode with its command-line tools, the Homebrew package manager, and the project generator, which is one brew install. The auto-update framework is named as the only external dependency and is said to be pulled in automatically by the editor through its package manager, so nothing is vendored and nothing needs manual wiring. Signing is configured through three environment variables, a team identifier, an account identifier and a signing identity name, and the root carries a plist of export options, which is the usual companion to that. The end-user path avoids all of it by downloading a disk image instead, from the releases page.
The repository ships a skill for coding agents, and a site in another framework
Two things in the tree have nothing to do with the application. The first is an agent skill file inside a hidden directory, described as giving coding agents full context on the project, its architecture, its key files and its common tasks, and as being picked up automatically by one of the tools the app manages. That is a nice bit of dogfooding: a manager for agent skills that ships its own. The second is a marketing site in its own directory built with a different framework and its own package install step, which is a separate deployment surface with its own lockfile. A third detail is worth noting for anyone reading the metadata: the project's licence field records nothing recognisable while a licence file sits at the root.
Editorial conclusion
This suits someone whose agent configuration has spread across half a dozen tools and who wants one window over all of it, with real-time watching so a hand edit on disk shows up immediately. Two things to know first. It runs with the application sandbox switched off, by design, because reading dotfiles across the home directory is the product, so decide whether you want an unsandboxed app holding that view. And there is no automated test suite at all, which matters more if you fork it than if you use it, since changes are validated by building and clicking through the feature you touched.
Frequently asked questions
What is Shpigford/chops?
It is a native macOS application for discovering, organizing and editing the skill and agent files that coding assistants keep in dotfile directories. It scans those directories for several tools, deduplicates by resolved symlink so a shared file appears once with a badge per tool, offers a built-in monospaced editor with frontmatter parsing, and can also browse and install from an external skill registry.
Which tools does Chops scan?
A global shared skills directory plus five tools that have both skills and agents directories, and one tool that has only a skills directory. Two further tools are supported but detect only project-level skills and agents, with no global paths. Custom scan paths can be added for any tool, and the tool definitions all live in one enumeration file.
Why does Chops need unrestricted filesystem access?
Because the directories it scans are dotfile directories across your home folder, several of which the operating system would otherwise fence off. The project lists disabling the application sandbox as a deliberate design decision and states the entitlements file turns it off, describing it as required for core functionality.
How do I build Chops from source?
You need the current macOS release or later, Xcode with command-line tools, Homebrew and the project generator. Then clone, install the generator if needed, run the generator to produce the Xcode project from its specification, and open it. A single command-line build of a debug configuration is also documented for people who do not want the editor. The generated project is committed but should not be edited directly.
Does Chops have automated tests?
No. The project lists having no test suite as one of its design decisions and repeats it in the testing section, which gives a four-step manual procedure: build and run, trigger the exact feature you changed, observe the behaviour and error messages, then check edge cases such as empty states, missing directories and malformed files.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/shpigford-chops)Star history chart for your README
[](https://hysenlabs.com/projects/shpigford-chops)Was this useful?