QUICK ANSWER

Record your screen, explain what you want done, and give the Clipy link to your agent. It can work from the walkthrough and show you the result with a recording of its own. The exchange stays familiar: show the task, ask for the change, then look at what came back.

Use this recording to make the change, then show me the result with Clipy: [link].

The story: Claude Code fixes a bug and hands you a recording

Here's the workflow we actually built this for. You're pairing with Claude Code. It finds the bug, writes the fix, and (instead of typing "done, I changed the effect dependency array") it opens your running app, reproduces the old behavior, applies the fix, and shows it working. Then it hands you a link.

Share the normal Clipy recording link with your agent. The skill handles retrieving the available recording context. Tell the agent the outcome you want, and ask it to identify any evidence it could not retrieve.

The output is a normal Clipy recording that a teammate can open. The agent handles the recording workflow, and the reviewer gets something concrete to inspect.

How do you connect your agent?

Start with the recording link and the task. If the agent needs the Clipy skill or account access, ask it to handle setup and guide you through anything it needs. You can keep explaining what you want in ordinary language.

How do you ask for a recording of the work?

Verify this change in the running app. Record the verification with Clipy and attach the Clipy proof link to this GitHub PR: [PR link]. Show the problem before the fix and the result after it.

The agent handles recording and sharing. Open the proof link in the PR to see what it actually checked. Ask it to include the important screens and a reload when the change should persist.

A recording shows the run that was captured, not every possible case. If the agent cannot record in its current environment or cannot update the PR, it should say so. A walkthrough assembled from screenshots should be labeled as such, not presented as continuous screen capture.

What if the work is in a real app window?

Name the app and the exact flow that needs verification. The agent should record that environment using its available tools, with the right account and recording permissions. The Clipy Mac app covers native Mac workflows, and a server-only agent records a browser or a Linux screen with the Clipy CLI.

If the target is unavailable, ask for a clear account of what was and was not tested. A different screen is not a substitute for the requested verification.

Share the normal Clipy link. The skill handles reading the recording context, and public recordings need no viewer account. Your teammate opens the same link to watch the video.

Read this Clipy recording and help me with the change I described: [paste the recording link]. Tell me what you understood before editing.

Key moments, not just words

What makes that markdown worth reading is that it's more than a transcript. Clipy pulls the frame at every pointer: every spot where the speaker, or the agent's mark, draws attention to something on screen. When a recording carries a click track (Mac app captures and Chrome-extension tab recordings) it fuses in the real click coordinates, normalized as fractions of the frame, so a moment isn't "somewhere over there" but a precise point. And on Mac app recordings it goes one further: it captures the accessibility role and label of the element that was actually clicked. So a key moment reads "clicked the Settings button at (0.63, 0.41)": the frame is ground truth, the coordinates are machine-checkable, and the label names the target. It's a repro that actually reproduces, not a paraphrase of one.

What about private-library access?

Ask the agent to connect your Clipy library when it needs to search your recordings or read private material. It will guide the sign-in and connection steps. The MCP reference is there when technical details are needed.

Why we built the recording half

The reading half was the obvious first move: agents are good at turning a messy screen recording into a crisp list of issues, and a recording context endpoint made that a one-line integration. We're not the only ones who saw it: Jam.dev's MCP lets an agent read a captured bug session, and it's a genuinely good idea. But reading is only half the loop. As long as agents could consume recordings and never produce them, every "show me it works" still fell back to a human hitting record, or worse, to a wall of text asserting that it works.

Closing the loop changes what a handoff looks like. A fix that arrives with a recording is one you can trust at a glance instead of pulling the branch and reproducing it yourself. A bug an agent files against your app can carry the repro clip it made while finding it. Async review stops being "read this diff and imagine the behavior" and becomes "watch the part where the behavior changed." We've written before about how bug repros that write themselves beat a paragraph of description; agent-made recordings are that idea, automated.

And it means the evidence and the fix come from the same place, in the same step. Every recording already carries a transcript, a summary, key moments, and (on click-tracked captures) the exact element that was clicked. Until now an agent could only read that; handing it the other end of the pipe closes the gap between doing the work and showing it.

What should you ask on your next task?

Use this recording to fix the issue. When you finish, verify the change and attach Clipy proof to the GitHub PR: [recording link].

If Clipy is not set up in that agent yet, ask it to install the skill first.