To record a bug on Mac, press Cmd+Shift+5, choose full screen or a selected area, click Record, then reproduce the bug and click Stop in the menu bar. That gets you a .mov on your Desktop — but for a bug report you usually need system audio, a shareable link, and the click-by-click context that the built-in recorder throws away. This guide covers both.
Disclosure: Clipy is our product. We've kept this comparison factual and cite sources for competitor claims — tell us if anything is stale.
The built-in way: Cmd+Shift+5
macOS ships a screen recorder, and for a five-second "look, the button is broken" clip it's genuinely fine. Here's the whole flow:
- Press Cmd+Shift+5 to open the Screenshot toolbar.
- Pick Record Entire Screen or Record Selected Portion (drag to size the box).
- Click Options and turn on your Microphone if you want to narrate.
- Click Record, reproduce the bug, then click the Stop button (the small square) in the menu bar.
- The recording saves to your Desktop as a
.mov. A thumbnail floats in the bottom-right corner — click it to trim.
Apple documents this flow in its official record the screen on Mac support article, and QuickTime Player offers the same capture with a windowed UI if you prefer an app.
Where Cmd+Shift+5 falls short for bug reports
The problem isn't the capture — it's everything a bug report needs that the built-in tool doesn't do.
- No system audio. This is the big one. Cmd+Shift+5 records your microphone but not the sound your Mac is actually playing. If the bug is "the notification chime fires twice" or "the video stutters," the built-in recorder can't capture it without a virtual audio driver like BlackHole or Soundflower — a 10–15 minute setup with a kernel extension and a restart.
- No shareable link. You get a file on your Desktop. To send it you upload to Slack, Drive, or WeTransfer, wait, then paste a link. A one-minute 4K recording can be hundreds of megabytes.
- No context. The engineer who receives it sees pixels. They don't get a transcript, they don't get "which button was clicked," and they can't hand the clip to an AI coding agent to triage.
- No trim-and-annotate on the way out. You can trim, but there's no way to mark the exact moment the bug happened for someone scrubbing later.
For a quick internal note, that's acceptable. For a bug that another human — or an AI agent — has to reproduce and fix, you want more.
What a good Mac bug recording actually needs
A bug report is only useful if the person on the other end can reproduce the failure without a back-and-forth. That means the recording should carry:
- System audio + mic, so audio bugs and your narration both survive.
- The whole workflow, not one tab — real bugs cross an app boundary, a terminal, and a browser.
- What was clicked, not just where the cursor was.
- A link you can paste in under two seconds, unlisted by default.
- A machine-readable version, so an AI agent can read the recording instead of watching it.
The built-in recorder gives you the first item (mic only) and none of the rest. A purpose-built Mac app closes the gap.
Record a bug on Mac with Clipy
Clipy is a free Mac screen recorder built for exactly this. It's a native Apple Silicon app (macOS 13+), no watermark, no credit card, unlimited recording length. Here's the bug-report flow:
- Download the Mac app from clipy.online/download and grant Screen Recording, Microphone, and Accessibility permission on first launch (macOS asks once).
- Hit your record hotkey and pick the whole screen or a single window.
- Turn on system audio + mic. Clipy captures both natively — no BlackHole, no Soundflower, no aggregate audio device.
- Reproduce the bug across whatever apps it touches: click through your web app, drop into a terminal, trigger the Electron helper. Clipy is recording all of it.
- Click Stop. A share link lands on your clipboard in under two seconds — unlisted by default. Paste it into Slack, Linear, or a GitHub issue.
That's the recording. What makes it a bug report is what Clipy captures underneath the video.
It captures the whole screen, not one tab
Clipy records at the OS level using Apple's ScreenCaptureKit. That means it captures the full screen or any window across every application — your browser, your native app, your terminal, your menu bar — in one recording. A bug that starts with a bad API response in the browser, throws an error in your Electron desktop app, and leaves a stack trace in a terminal is one video, not three.
It records what you clicked, not just where
This is the part no browser tool can reach. On every click, Clipy reads the macOS Accessibility (AX) layer and records the semantics of the element under the cursor — the AX role (AXButton, AXLink, AXTextField) plus the element's visible label (its AXTitle or AXDescription) — not just an x/y pixel coordinate. So instead of "user clicked at 812, 447," the recording knows "user clicked the Submit button." Clipy also writes a cursor sidecar with millisecond-precision movement and click timings, so the exact moment of failure is anchored in the timeline.
It bridges browser console + network logs on Mac
For bugs that start in the browser, the Clipy Mac app bridges browser console and network logs from Chrome via Native Messaging into the recording — so a failed request or a thrown exception in the tab lands in the same document as the video and the click trail, with no separate DevTools export.
It's readable by AI agents
Every clipy.online/video/<id> link is also a fetchable .md document (add ?format=md or .json). That document contains an AI summary, action items, key moments with extracted frame images and click coordinates, and the full transcript. An AI coding agent — Claude Code, Cursor, Codex — can read the recording instead of watching it. Two ways in, both live: the Clipy agent skill (agents learn that any Clipy link is fetchable as .md, no setup), or the MCP server:
npx -y @clipy/mcp
Paste this into your agent after a teammate sends a Clipy bug link:
Read this recording and reproduce the bug:
https://clipy.online/video/<id>?format=md
The agent gets the summary, the transcript, the key frames, and the click semantics — a reproducible bug report, machine-readable, from one screen recording.
Why browser extensions can't reach native Mac bugs
The obvious alternative for bug capture is a Chrome extension like Jam.dev, which is a strong, mature tool: one-click capture, console and network logs, device metadata, and Jira/Linear integrations, all built for developers filing browser bugs.
But a Chrome extension lives inside the browser sandbox. Its capture ends at the tab boundary. The moment your bug involves anything outside Chrome — a native menu, a file dialog, an Electron app, a terminal window, a second monitor, a system-audio glitch — a browser extension can't see it. That's not a knock on Jam's engineering; it's the hard limit of where a browser extension is allowed to run.
Native capture doesn't have that boundary. If your bugs are purely inside a web page, a browser tool is a fine, focused choice. If your bugs span your whole Mac, you need something that records the whole Mac.
Cmd+Shift+5 vs QuickTime vs Jam vs Clipy Mac app
| Cmd+Shift+5 | QuickTime | Jam (Chrome ext) | Clipy Mac app | |
|---|---|---|---|---|
| System audio (no extra driver) | No | No | Browser only | Yes (macOS 13+) |
| Records across apps / terminal | Yes (video only) | Yes (video only) | No — tab only | Yes |
| Click semantics (what, not where) | No | No | Click logs (in-tab) | Yes (AX role + label) |
| Instant share link | No | No | Yes | Yes (<2s, unlisted) |
Agent-readable .md of the recording |
No | No | Has its own MCP | Yes (skill + MCP) |
| Price | Free (built in) | Free (built in) | Free tier; paid teams | Free, no watermark |
Feature notes as of July 2026. Verify competitor specifics on their live pages — Jam's pricing and Apple's recording docs change over time.
For a deeper head-to-head on the browser-versus-native trade-off, see Jam vs Clipy.
FAQ
Does Cmd+Shift+5 record system audio on Mac?
No. The built-in Mac recorder captures your microphone but not the audio your Mac plays. To capture system audio with Cmd+Shift+5 or QuickTime you need a virtual audio driver like BlackHole (free, but a kernel extension and a restart). A native app such as Clipy records system audio and mic together with no driver setup.
How do I record a bug on Mac for free?
Press Cmd+Shift+5, enable your microphone under Options, record the bug, and share the .mov. For a report with system audio, a share link, and click context, use a free purpose-built Mac recorder like Clipy — unlimited length, no watermark, no credit card.
Where does Mac save screen recordings?
By default, Cmd+Shift+5 and QuickTime save recordings to your Desktop as .mov files. You can change the location in the Cmd+Shift+5 Options menu under "Save to." Tools that generate a share link store the file in the cloud instead, so you paste a URL rather than upload a large file.
Can an AI coding agent read a Mac screen recording?
Yes, if the recording exposes a machine-readable document. A Clipy link is fetchable as .md (add ?format=md), containing a summary, transcript, key moments with frames, and click coordinates. Agents like Claude Code or Cursor read that instead of watching the video — via the Clipy skill or npx -y @clipy/mcp.
What's the best Mac screen recorder for bug reports?
If your bugs are browser-only, a Chrome extension like Jam is purpose-built for that. If your bugs cross apps, a terminal, or need system audio, a native Mac recorder is the better fit — it captures the whole screen, records what you clicked (not just where), and produces a shareable, agent-readable link.