Chops: a macOS app for browsing and editing AI agent skills across Claude Code, Cursor, Codex and Amp

The dotfile sprawl Chops was built to fix

Skills and agent definitions accumulate in per-tool directories. Claude Code reads from ~/.claude/skills/ and ~/.claude/agents/, Cursor from ~/.cursor/skills/ and ~/.cursor/agents/, Codex from ~/.codex/skills/ and ~/.codex/agents/, Windsurf from ~/.codeium/windsurf/memories/ and ~/.windsurf/rules, and Amp from ~/.config/amp/skills/. There is also a shared global location, ~/.agents/skills/. That is a lot of hidden folders to remember, and the README's own framing is blunt: stop digging through dotfiles.

The intended user is a developer who already runs more than one of these agents and keeps the same skill in several of them. The problem Chops addresses is not writing a skill, it is knowing which skills exist, which tool can see them, and what is inside each file. Copilot and Aider are listed as supported too, but only for project-level skills and agents, since the README says they have no global paths. That distinction matters if you expected the app to find a Copilot configuration outside a project directory. Custom scan paths can be added for any tool, which is the escape hatch when a tool stores its files somewhere the built-in list does not cover.

How the scanner, the parser and FSEvents fit together

The architecture is a native SwiftUI and SwiftData app with no web views. On launch, ChopsApp builds a SwiftData ModelContainer that persists Skill and SkillCollection objects, then starts the Sparkle updater in the background. AppState, an @Observable class, is injected into the SwiftUI environment, and ContentView renders a three-column NavigationSplitView before calling startScanning().

SkillScanner probes the tool directories and upserts what it finds into SwiftData. SkillParser then dispatches each file to FrontmatterParser for YAML frontmatter in .md files or to MDCParser for Cursor .mdc files. FileWatcher attaches FSEvents listeners, and the README states that any change triggers a re-scan automatically. Search runs in memory through SearchService across name, description and content.

Two design decisions are worth naming. Skills are uniquely identified by their resolved symlink path, so a file symlinked into several tool directories appears once with multiple tool badges. And the app disables the sandbox on purpose: the entitlements file explicitly turns it off because reading dotfiles across the home directory requires unrestricted filesystem access. Tool definitions are centralised in Chops/Models/ToolSource.swift, where each enum case carries its display name, icon, color and filesystem paths.

The detail pane wraps NSTextView for native text editing, with Cmd+S to save, and the README describes frontmatter parsing as part of the editor. Collections are stored separately from the files, so grouping skills does not rewrite the source files on disk. That separation is the reason the app is safe to use as a browser even if you never save an edit.

Installing Chops from source and opening your first skill

End users are pointed at the latest release DMG. Building locally needs macOS 15 (Sequoia) or later, Xcode with command-line tools, Homebrew, and xcodegen installed through Homebrew. Sparkle is the only external dependency and Xcode pulls it through Swift Package Manager.

Start by installing the command-line tools and xcodegen if they are not already present.

xcode-select --install
brew install xcodegen

Then clone the repository, generate the Xcode project and open it. The README warns that the project file is generated from project.yml, so this step is not optional and the .xcodeproj should not be edited directly.

git clone https://github.com/Shpigford/chops.git
cd chops
xcodegen generate
open Chops.xcodeproj

With the project open, Cmd+R builds and runs the app. The README gives a headless alternative for people who would rather not use the Xcode GUI.

xcodebuild -scheme Chops -configuration Debug build

On first launch the scanner runs immediately, so the sidebar should already list the tools whose directories exist on your machine. Pick a skill in the middle column and it opens in the monospaced editor on the right; Cmd+S writes the file back. If a directory you expected is missing, add it as a custom scan path rather than editing the tool list in source. If you change project.yml later, re-run xcodegen generate before building again.

No sandbox, no tests, and a macOS 15 floor

The most consequential limitation is stated plainly in the repository: the app sandbox is disabled, and the entitlements file does so intentionally, because reading dotfiles across the home directory needs unrestricted filesystem access. That is a reasonable engineering trade-off for this kind of tool, but it means Chops is not the sort of app you can expect to find sandboxed and distributed through the Mac App Store. Anyone who treats sandboxing as a requirement should look elsewhere.

The second limitation is the absence of a test suite. The README tells contributors to validate changes manually by building, running, triggering the feature they changed and observing the result. For an app whose core job is writing to files in your home directory, that is a meaningful gap: a parsing regression in FrontmatterParser or MDCParser would surface as a corrupted or misread skill rather than a failing test. If you plan to modify the parsers, budget time for manual checks on real files.

The third is the platform floor. macOS 15 (Sequoia) or later is required, so older Macs are out, and there is no Linux or Windows build, since the app is SwiftUI and SwiftData with FSEvents watching. The README also does not document rollback behaviour for edits, so if you need version history for your skills, keep them in git rather than relying on the app. Copilot and Aider support is limited to project-level detection, which makes Chops a poor fit if those are your only agents and your skills live in a global directory.

Where Chops sits next to plain grep and an editor

The realistic alternative is not another GUI. It is the combination most people already use: ripgrep or grep across the dotfile directories, plus your existing editor open on the file path. That approach has real advantages. It works on any operating system, it costs nothing to install, and it never writes to a file you did not explicitly open. If you only have one agent installed and a handful of skills, this is genuinely the better tool, and Chops adds a layer you do not need.

The difference in approach shows up once there are several agents involved. Grep tells you that a string exists somewhere; it does not tell you which tool owns the directory, whether two paths are the same file behind a symlink, or what the frontmatter says. Chops resolves symlinks so a shared skill appears once with multiple tool badges, parses frontmatter and .mdc files into structured metadata, and keeps collections in SwiftData without touching the source files. It also watches the filesystem through FSEvents, so an edit made in another editor shows up in the app without a manual refresh. A terminal search gives you none of that, and the trade is that you accept an unsandboxed native app instead of a one-line command.

Maintenance, releases and the licence question

The repository is not archived, and the last push was on 2026-08-23, the same day v1.16.0 was released. The release history is uneven rather than steady: v1.14.0 landed on 2026-04-03, v1.15.0 on 2026-04-29, and then v1.16.0 on 2026-08-23 after a gap of nearly four months. That pattern suggests maintenance happens in bursts, so pinning to a release you have checked is more sensible than tracking main.

Upgrade cost is low for end users. Sparkle is bundled and the README describes it as the auto-update framework, so the app updates itself from the release feed. Building from source has a different cost profile: the Xcode project is generated from project.yml, so any pull that touches that file requires another xcodegen generate before the build matches the repository. Contributors also need to keep the manual validation habit, since there is no test suite to catch a bad change.

The licence is the least clear part. The repository's licence is reported as NOASSERTION, which means GitHub could not map the LICENSE file to a known identifier. That is not the same as having no licence, but it does mean you should read the LICENSE file in the repository root yourself before you fork, redistribute or bundle the app. Nothing here is legal advice, and the README does not discuss licensing terms at all.

Editorial conclusion

Adopt Chops if you run Claude Code, Cursor, Codex, Windsurf or Amp on macOS 15 and your skills are already scattered across several dotfile trees, because the scanner and the FSEvents watcher are the parts that save time. Do not adopt it if you are on Linux or Windows, if you want a sandboxed app, or if you need a covered test suite before trusting a tool that writes to your dotfiles. Before installing, check that your Xcode command-line tools, Homebrew and xcodegen are present, clone the repository, run xcodegen generate, and confirm the app can read the specific paths you care about, including any custom scan path you have added.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. Shpigford/chops on GitHub