Snip: a visual review layer for Claude Code and other AI coding agents
The visual communication layer between humans and AI agents. Capture, annotate, render diagrams, and organize with AI — powered by Electron and Ollama. macOS & Linux.
At a glance
- What is it?
- Snip is an Electron menu bar app with a CLI that lets an AI coding agent render Mermaid diagrams and HTML previews for a human to approve or annotate. It installs via Homebrew on macOS or an AppImage/deb on Linux, and its AI features run against a local Ollama model.
- Who is it for?
- Adopt Snip if you drive Claude Code or another shell-capable agent and keep losing time to text descriptions of architecture and data models. Skip it if you need Windows support (the README lists macOS and Linux only), if you cannot run Ollama locally, or if you want a headless review loop with no GUI session.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 132 days ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap Snip fills between an agent's text output and a human reviewer
An AI coding agent describing an architecture in prose is a lossy channel. You read a paragraph, build a mental model, and then discover the model was wrong when the code lands. Snip's answer is to move that exchange into images. The README frames the project as "Visual mode for Claude Code", and the loop it describes is concrete: the agent writes a Mermaid diagram or an HTML preview to a file, calls the CLI, and the app opens a window showing the render. You either approve or annotate on screen. The agent receives structured JSON back and iterates.
The target user is someone already running an agent that can execute shell commands, primarily Claude Code, with Cursor, Windsurf and Cline named as also working. The second audience is people who just want a screenshot and annotation tool with local AI organization, since Snip ships that as a standalone feature set with its own keyboard shortcuts. Those two audiences overlap more than they look: both depend on the same menu bar process and the same local model stack.
How the CLI, the menu bar process and the MCP server fit together
Snip is an Electron application whose entry point is `src/main/main.js`, with a CLI binary exposed as `snip` through the `bin` field in package.json. The agent never talks to Electron directly. It shells out to the CLI, and the CLI hands the request to the running app, which opens the review window. This is why the README describes `render` and `open` as blocking calls: the process waits until you finish, then returns a result object shaped like `{ status: "approved" | "changes_requested", edited, path, text }`. That contract is the whole integration. An agent that can read JSON can branch on `status` and either continue or revise.
For agents without shell access, such as Claude Desktop or hosted environments, the repository includes an MCP server at `src/mcp/server.js` exposing the same operations under tool names like `render_diagram`, `open_in_snip`, `search_screenshots` and `transcribe_screenshot`. The underlying AI work is local: the tech stack lists Ollama for the vision LLM, HuggingFace Transformers.js, and SlimSAM via ONNX for the AI segment tool. The README states that all AI runs locally and that no cloud APIs are needed for core features. That is a design commitment with a cost, because it makes Ollama a runtime dependency rather than an optional extra.
Installing Snip and running a first diagram review
On macOS the README gives a Homebrew cask, which is the shortest path because it handles the app bundle placement for you.
brew install --cask rixinhahaha/snip/snipOn Linux there is no package manager step in the README. You download from the Releases page and pick either the AppImage, described as portable for any distro with a filename like `Snip-x.y.z-x86_64.AppImage`, or the deb for Ubuntu and Debian. The README notes the macOS DMG is Apple Silicon only, so Intel Macs are not covered by the published build.
Once the app is running, the setup command configures your agent. The README says it installs rules, a `/diagram` skill and permissions for Claude Code, and also covers Cursor, Windsurf and Cline.
snip setupAfter that, a diagram review is a single piped command. The agent writes Mermaid source to a file and streams it in; according to the README, the app opens for review and the command blocks until you approve or annotate.
snip render --format mermaid < architecture.mmdThe same pattern works for an HTML component preview with `snip render --format html < preview.html`. If you want to check the screenshot side first, `snip open screenshot.png --message "Is the layout correct?"` opens any image for annotated review, and `snip search "login page error"` queries the library by description rather than filename. Development setup, if you are building from source, is `npm install`, then `npm run rebuild` to compile native modules on macOS, then `npm start` to launch the tray icon. That path requires macOS 14+ or Linux with Wayland and Node.js 18+.
Where Snip stops being the right tool
The blocking behaviour is the sharpest limitation. Because `render` and `open` wait for a human, any agent workflow that assumes a fast, non-interactive tool call will stall until someone clicks. In an unattended CI job or a long autonomous run, that is a hang, not a feature. The README does not document a timeout flag or a non-blocking mode, so there is no stated way to cap the wait.
Platform coverage is the second constraint. The README lists macOS and Linux only, and the macOS DMG is Apple Silicon, so Windows users and Intel Mac users have no published install path. Linux also carries a Wayland requirement in the development section, which excludes X11-only sessions for building from source even though the AppImage may still run.
The local AI design is a trade-off rather than a flaw, but it is a real one. Organization, semantic search and OCR depend on a local vision model served through Ollama. If Ollama is not installed or the model is not pulled, those features have nothing to call. The README links to the Ollama download page but does not document which model to pull, so the first run of `snip organize` is a place where you may need to read the source. Anyone who wants screenshot search without managing a local model server should look elsewhere.
How Snip differs from a plain screenshot annotator
Tools like Flameshot or the built-in macOS screenshot editor solve capture and markup, and they solve it without a background process or a language model. The difference in approach is what happens after the pixels exist. A conventional annotator produces a file and stops. Snip treats the annotated image as a message: the annotations, the text feedback and the approve or reject decision are serialized into JSON and handed back to the process that requested the review, which is usually an AI agent mid-task.
That inversion matters for how you evaluate it. If your workflow ends with a PNG in a folder, Snip's extra machinery is overhead you will not use, and the tray process plus Ollama will feel heavy. If your workflow ends with an agent that needs to know whether its output was accepted, the JSON return value is the entire point, and no ordinary screenshot tool provides it. The MCP server widens the same idea to agents that cannot run shell commands, which is a category most annotators never address.
Maintenance cadence, licence and the cost of upgrading
The repository is not archived, and the last push was on 2026-05-07, the same day as the v1.3.14 release. The two prior releases, v1.3.13 and v1.3.12, landed on 2026-04-11 and 2026-04-10, so the visible release pattern is bursts rather than a steady cadence. Treat the project as maintained but not fast-moving, and check the Releases page before assuming a fix has shipped.
Upgrade cost depends on how you installed it. The Homebrew cask updates through Brew, and the package.json lists `electron-updater`, so the app carries its own update path. Linux users on the AppImage or deb have no documented auto-update route in the README and should expect to re-download. Building from source adds native module compilation: the `prebuild` and `postinstall` scripts run `node-gyp rebuild` and `electron-builder install-app-deps` on macOS only, so a source build on Linux skips those steps and may behave differently.
The licence is MIT, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are preserved. That is a permissive grant, but it says nothing about the licences of the bundled models or of Ollama itself, and the README does not address those. If you plan to redistribute Snip inside a product, check the model and runtime licences separately; this article is not legal advice.
Editorial conclusion
Adopt Snip if you drive Claude Code or another shell-capable agent and keep losing time to text descriptions of architecture and data models. Skip it if you need Windows support (the README lists macOS and Linux only), if you cannot run Ollama locally, or if you want a headless review loop with no GUI session. Before committing, verify three things: that `snip setup` writes the rules and permissions your agent actually reads, that the structured JSON returned by `snip render` matches what your agent's tool loop expects, and that your machine meets macOS 14+ or Linux with Wayland and Node.js 18+.
Frequently asked questions
Does Snip work on Windows?
The README lists macOS and Linux only, and the development requirements name macOS 14+ or Linux with Wayland. There is no Windows install path documented in the repository.
Do I need Ollama to use Snip?
The README says AI organization uses a local vision LLM via Ollama, and the tech stack lists Ollama as the local model runtime. Core features are described as running locally with no cloud APIs, so Ollama is the dependency for the AI parts rather than for capture and annotation.
What does snip render return to my AI agent?
The README states that review commands block until the user finishes and return structured JSON in the form { status: "approved" | "changes_requested", edited, path, text }. The agent can branch on that status value.
Community notes