FOR CLAUDE CODE
Screen Recorder for Claude Code
Record it once. Humans watch it, agents fix it.
Clipy is the agent-readable screen recorder for Claude Code. Record the bug once and paste the normal share link into a Claude Code session — with the Clipy skill installed, it fetches the recording's markdown twin and gets the summary, key moments with frames, click targets, cursor paths, and the timestamped transcript.
The whole loop in under a minute. Tap for sound.
One recorder, every workflow
Clipy is for every use case
Same loop, whatever your team does: record once, share one link, and an AI agent reads it and acts. Switch roles to see it play out.
Agent-ready fast
Chunks stream to the server while you record, so the moment you stop the summary, key-moment frames, and transcript are already building — a short clip is agent-ready in seconds.
Our own pipeline
On-device transcription and key-moment fusion we built ourselves — not a third-party API bolted on — tuned for speed and for the exact context an agent needs to act.
Fastest agent loop
The fastest agent-ready screen recorder: one link a teammate watches and an AI agent reads. No ticket, no repro write-up, no re-explaining.
Claude Code lives in the terminal — and the terminal can’t see your screen
You hit a bug, you switch to your Claude Code session, and now you have to type the screen into it: which page, which button, what happened on the second click, what the error toast said. The agent can’t watch an MP4, so you become the lossy adapter between what you saw and what it gets — a paragraph of repro steps that’s always a little wrong. The fix Claude Code writes is only as good as your description, and the description is the weakest part of the loop.
How it works
- 1
Record the bug
Screen, tab, or window — narrate what breaks and click through it once. No ticket-writing.
- 2
Paste the link into Claude Code
The Clipy skill recognizes clipy.online/video links and fetches the agent-readable document automatically.
- 3
Review the PR
Claude Code sees the frame you pointed at, greps the codebase for the button it can literally see, and ships the fix.
One curl install, then a link is the whole prompt
Clipy is the agent-readable screen recorder built for exactly this handoff. Install the Clipy skill once — a single curl command from /docs/skill drops a SKILL.md into your skills directory — and Claude Code learns the convention for good.
After that there is no prompt setup. You paste a normal clipy.online/video/<id> link into your Claude Code session and the skill recognizes it, fetches the recording’s markdown twin, and reads it. No screenshots to attach, no DOM to describe, no “here’s what the modal looked like.” The recording already is the context.
Install once
curl the skill from /docs/skill. It’s a plain SKILL.md convention — no daemon, no config file, nothing to keep running.
Paste the link
Any public Clipy link resolves to its .md twin. The skill triggers on the URL pattern, so you don’t even have to say what it is.
No prompt scaffolding
Skills remove the setup tax. You stop writing “the recording shows…” and just drop the link.
Claude Code reads the frame, then greps your repo for it
The document the skill fetches is not a transcript dump. It’s an AI summary, the full timestamped transcript, and key moments — each key moment is the extracted frame at the instant you pointed or clicked, with the real click coordinates on Mac-app and Chrome-extension recordings.
That’s the part that makes an agent-readable screen recording actually actionable in a terminal. Claude Code’s vision reads the frame image directly — it sees the button, not your sentence about the button — and then does what it does best: greps the repo for that exact label, finds the handler, and works from the code up. The frame tells it what; your codebase tells it where.
Vision on the frame
Claude reads the extracted image, so “the Export button” is a thing it can see, not a string it has to guess.
Coordinates to selector
Click coordinates land it on the exact element; from there it greps your source for the matching label or test id.
Grounded edits
Every change traces to a frame and a line — not to a paraphrase of a bug report.
Public links need no key; private recordings use the MCP server
For anything you can share, the skill path is all you need — public links resolve with no API key, so a teammate’s recording drops straight into your session.
When the recording is internal, add the Clipy MCP server (@clipy/mcp) with a personal key from clipy.online/settings/api-keys. Same summary, same key moments, same transcript — now authenticated, plus library search so Claude Code can find the right recording by what was said in it, not just by a URL you remembered to save.
A double-download bug, fixed from a 12-second clip
The Export CSV button on your reports page fires twice — two files land in Downloads every click. Instead of writing that up, you record it: click Export, show the two files, say “this should only download once.” Twelve seconds, hit stop, copy the link. In your Claude Code session you paste clipy.online/video/… and nothing else. The skill fetches the .md twin, reads the key moment where your cursor sits on Export CSV with its coordinates, and reads your narration as the expected behavior. Claude Code greps the repo for “Export CSV,” finds the onClick wired without a guard so a re-render double-binds it, patches the handler, and opens a PR — while you never typed a single reproduction step.
Zero prompt setup
The skill installs once and then triggers on the link itself. You don’t assemble a prompt, attach screenshots, or explain the UI — you paste a URL and the agent already has the frames, clicks, and transcript.
Public links, no API key
A public clipy.online/video link works in Claude Code with no credentials wired up. Share a recording, paste it, done — the skill resolves it to the markdown document on its own.
Claude’s vision reads the frame
Key moments carry the real extracted frame, so Claude Code sees the actual button, panel, and error state. It’s reading the pixels, not your best-effort description of them.
The recording is the reproduction
No ticket, no repro list, no re-explaining the flow. The click you made is the click the agent gets — with coordinates — so the walkthrough itself is the reproduction the fix is built against.
Handing a bug to Claude Code
| The old way | With an agent-readable recording | |
|---|---|---|
| Handoff | Type repro steps into the terminal and hope they match what you saw. | Paste one link; the skill fetches the summary, frames, clicks, and transcript. |
| Prompt setup | Attach screenshots, describe the DOM, name the button in prose. | None — the frame and click target are already in the document the skill reads. |
| What the agent sees | Your written description of the UI, one abstraction removed from the pixels. | The actual frame image plus click coordinates at the moment it happened. |
| Finding the code | The agent guesses selectors from your words and often picks the wrong element. | It greps your repo for the exact label it can read in the frame. |
| Access | Wire up an API key before any tool can pull the recording. | Public links need no key; the skill resolves them. MCP + key only for private. |
Common questions
How do I install the Clipy skill for Claude Code?
One curl command from /docs/skill drops a SKILL.md into your skills directory. There’s nothing to configure and nothing to keep running — after the install, Claude Code recognizes clipy.online/video links on its own.
Does Claude Code need an API key to read a Clipy link?
Not for public links. The skill resolves any public clipy.online/video/<id> to its markdown twin with no credentials. You only need a key for private recordings, which go through the Clipy MCP server.
What does Claude Code actually get from the link?
An AI summary, the key moments — each an extracted frame with click coordinates when captured — and the full timestamped transcript. It’s the recording translated into the two formats agents read: text and images.
Can Claude Code see the exact button I clicked?
Yes. Each key moment includes the frame at that instant, and Claude Code’s vision reads it directly. On Mac-app and Chrome-extension recordings the click coordinates are captured too, so it can map the click to a real element and grep your source for it.
Do I still have to write reproduction steps?
No. The recording is the reproduction — the clicks you made, in order, with the frames and your narration. That’s what makes an agent-readable screen recording faster than a ticket: there’s no write-up step between seeing the bug and handing it over.
How fast is a recording ready to paste into a session?
Chunks stream to the server while you record, so the summary, key moments, and transcript are already building when you hit stop. For a short clip the document is agent-ready within seconds — best case under about 10 seconds. It runs on Clipy’s own proprietary on-device pipeline, not a third-party API.
How do I hand Claude Code an internal recording that isn’t public?
Add the Clipy MCP server (@clipy/mcp) with a personal key from clipy.online/settings/api-keys. It gives Claude Code authenticated access to private recordings and lets it search your library by what was said, not just by a link.