QUICK ANSWER
Show the bug to your agent the way you would show a teammate: record your screen, reproduce the problem, and say what should happen. Give it the Clipy link and ask for a fix. When it finishes, ask it to show the same flow working so you can review the result.
Fix the issue shown in this Clipy recording, then show me the result: [link].
Disclosure: Clipy is our product.
The whole loop on one page
Here's the pipeline end to end before we break down each step:
- A teammate hits a bug and records it with Clipy, screen, voice, and the exact click.
- The share link lands in a Slack channel (it's live within ~2 seconds of pressing Stop).
- A developer pastes that same link into Claude Code.
- The agent fetches the recording's markdown document, summary, key-moment frames, click coordinates, transcript, and restates the bug in its own words.
- It writes a failing test, proposes a fix plan, implements, and opens a pull request.
- The agent (or the developer) attaches a new Clipy recording of the verification run to the PR, so the human reviewer watches the fix work instead of trusting a green check.
Steps 1–5 are shipped and boring in the best way. Step 6, agents producing recordings for humans to review, is the direction this is all heading, and it's where the loop closes on itself. More on that at the end.
Step 1: Record the bug, don't describe it
The single biggest time sink in bug reports is translation loss. The reporter knows exactly what happened; the ticket captures maybe 60% of it. A recording captures all of it and costs less effort than writing the ticket.
Clipy runs in the browser with no install, and also ships a Chrome extension, native Mac and Windows apps, and a Slack app. Recording is free to start, no cap on the length of a single recording, up to 4K, no watermark, no credit card, and no signup wall for whoever watches it later. The reporter just narrates while it breaks: "I click the Export button here, the spinner starts, and it never resolves."
That narration matters more than it looks. When they say "this button," Clipy captures the frame at that instant and, on Mac-app recordings and Chrome-extension tab recordings, the real click coordinates as fractions of the frame. On the Mac app it goes further: at each click it records the macOS Accessibility role and label of the element under the cursor (for example AXButton "Export"), not just a pixel. So "this button" resolves to an actual, named UI element instead of a vague gesture. That's the raw material an agent needs and a screenshot never has.
Step 2: The link travels in Slack
The reporter pastes the share link into your bug channel. For humans, it unfurls as a normal video preview they can click and watch, Slack renders shared links through its standard link unfurling behavior, and Clipy ships a Slack app for richer previews.
The important property: the same URL serves two audiences. A human watches the video. An agent, as we'll see next, reads a structured document from the exact same link. Nobody has to export anything, attach a transcript, or maintain a second artifact. One link, two readers.
Step 3: Give Claude Code the recording link
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.
Step 4: Ask for the outcome
Read this Clipy recording, explain the bug you see, and fix it in this project. Keep the change focused: [recording link].
Check the agent’s understanding before it edits. The skill handles reading the recording; you clarify any behavior the recording leaves ambiguous.
Step 5: From plan to pull request
A good agentic debugging workflow forces the agent to reason before it edits. The prompt above does this deliberately: it has to restate the bug and write a failing repro first. That single constraint is what separates a reliable AI bug fixing workflow from an agent that confidently rewrites five files and breaks three of them.
The agent comes back with something like: "The Export button calls exportReport(), which awaits pollJobStatus(). The frame at 0:14 shows the spinner in its loading state and the transcript confirms it never resolves. pollJobStatus() has no timeout and swallows the rejection, so the promise hangs forever. Here's the failing test." You read the plan, confirm the diagnosis matches the recording, and give the go-ahead.
From there it's a normal Claude Code session, it implements the fix, runs the suite, and opens the PR:
Run the relevant checks, record the verification with Clipy, and attach the proof link to the GitHub PR. Include the original repro recording so the reviewer can compare before and after.
Note the PR body already links the original recording via gh pr create. Anyone reviewing the PR can watch the exact bug it claims to fix. The context that started in Slack is now permanently attached to the change that resolved it. For a fuller tour of driving Claude Code from a recording, see recording bugs for Claude Code.
Traditional loop vs. agentic loop
| Stage | Ticket-and-screenshot loop | Agentic debugging workflow |
|---|---|---|
| Capture | Reporter writes repro steps from memory | Reporter records the bug as it happens |
| Handoff | Screenshot + text ticket | One link, humans and agent read it |
| Repro | Engineer re-derives steps, often fails | Agent reads frames + click coords, writes a failing test |
| Fix | Manual, context reconstructed | Agent proposes a plan, implements on approval |
| Proof | "Fixed, please retest" | Verification recording attached to the PR |
The row that changes the culture is the last one.
Step 6: Ask for Clipy proof in the PR
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.
FAQ
What is an agentic debugging workflow?
It's a debugging process where a human records a bug once and an AI coding agent reads that recording to reproduce, diagnose, and fix it, instead of a person re-typing repro steps into a ticket. The agent works from what was said and shown in the recording (transcript, key-moment frames, click coordinates), not from a lossy text summary.
Can Claude Code actually read a screen recording?
Not the raw video, but yes to a document derived from it. Claude Code doesn't watch MP4s; with the Clipy skill installed it fetches the recording's markdown twin, summary, timestamped transcript, and frame images of the moments the reporter pointed at, which is text and images, the two formats every agent understands. Install it from clipy.online/docs/skill.
Does the recording include console logs and network requests?
Yes, when you record with the Clipy Chrome extension. Alongside the transcript, key-moment frames and click coordinates, the extension captures console logs, network requests, GraphQL errors and WebSocket totals, and each click's accessibility label. Mac recordings add the clicked element's accessibility label too. The recording localizes the bug in the UI, and the logs localize it in the stack, in one link.
How does the agent know which button I meant?
Through key moments. When you say "this button," Clipy extracts the frame at that instant, and on Mac-app and Chrome-extension tab recordings it fuses the real click coordinates. On the Mac app it also records the element's Accessibility role and label. So "this" resolves to a specific, named element even when three buttons look alike.
Do I need to pay for any of this?
Clipy starts with a 7-day free trial, no card needed. Share links, transcripts, summaries, key moments, the recording context documents and the MCP server come with every plan, and viewers never need an account. Pro is $9 a month or $72 a year.