QUICK ANSWER

Record the bug with Clipy while you explain what should happen instead. Give Claude Code the recording link and ask it to fix the issue in your project. The walkthrough shows the screen, the action, and the unexpected result together, much like showing the problem to a teammate beside you.

Fix the UI bug I show in this Clipy recording: [link].

When does a UI bug need a recording?

Record when the order of events matters. A selection resetting after Save, a menu closing before you reach an item, and a validation message disappearing during typing are all sequences. A screenshot can show the final state while hiding the action that produced it.

For a stable visual problem, start with a screenshot. A clipped heading, incorrect icon, or obvious spacing mismatch may need only the image, viewport, and intended appearance. There is no benefit in making an agent inspect a recording when one frame already contains the relevant evidence.

Use text for a precise error or failed command. Include the literal output and reproduction command rather than recording a terminal just to make the agent transcribe it. You can combine text with a recording when an error appears during a visual interaction.

This is consistent with the distinction in Christopher Stoneberg’s recording-analysis tutorial: his example workflow extracts frames to inspect changes across time. His reported outcome is his own account, not a result reproduced in this guide. The useful principle is to choose evidence that preserves the behavior you need explained.

Before you start recording, finish this sentence: “The important change happens when I…” If the answer contains a sequence, a recording is likely useful. If it only identifies a static object, try an image first.

Can Claude Code see screenshots, recordings, and your live screen?

These are different inputs. Claude Code documents image support, including pasted images and local image paths. Anthropic also documents computer use for interacting with a live desktop in supported environments. It would be inaccurate to explain this workflow by saying Claude cannot see screens. Claude Code image workflows, computer-use documentation.

A saved Clipy recording takes another route. The Clipy skill retrieves a recording document containing the available transcript, summary, key moments, visual assets, and capture-gap information. Claude reads that material and can inspect the supplied images. In this workflow, it is not simply playing an MP4 in a human video player. Clipy skill documentation.

That distinction affects what you can expect. Transcript and frames follow shortly after playback; key moments carry click coordinates and labels. Live computer use can help reproduce a problem, but it does not automatically recover an earlier event that happened in a different session.

Think of the recording as a preserved report. Think of the agent’s browser or computer tools as its investigation environment. You may use both: first show what happened, then let Claude reproduce it against the application it is changing.

If you already have a local recording, you could extract frames and write the narration yourself, but every handoff repeats that work. A recording service that provides agent-readable context does it once, and Clipy keeps the transcript, frames and clicks attached to the same link your teammate watches. When a file must stay on your machine, Clipy's Local mode records without uploading and keeps the .arec context local.

For repeated handoffs that a teammate also needs to watch, a shareable recording with prepared context removes the steps you would otherwise repeat. When the question depends on runtime information outside the visible recording, record with the Clipy Chrome extension, which also captures console logs, network requests and GraphQL errors. This article walks through Clipy’s path and the checks you should apply to its output.

What should you prepare before recording the bug?

Open the affected page in a state you can explain. Use test data where possible, close unrelated views, and keep the recording focused on the surface involved. Check that the microphone captures your voice if narration will carry the expected behavior.

Write down the few environmental details that could change the result: the page or route, relevant account role, browser, viewport, and whether the problem follows a fresh load or previous interaction. You do not need to recite every version number. Include details because they matter, not because a bug-report template has an empty field.

Try the reproduction once before recording. This separates a known sequence from an exploratory session. If the bug is intermittent, say so. “This happened on one of three attempts” is different evidence from “This happens whenever I save.” Do not convert one observation into an always claim.

For the illustrative dropdown case, preparation could be: open Settings, choose a test account, confirm the current selection, and decide what should remain visible after Save. Keep the app’s own requirements handy if the expected behavior is disputed.

Choose your capture surface through the Clipy recording guide. Recorder capabilities vary. You should not assume every capture includes pointer telemetry, browser diagnostics, system audio, or the same visual detail.

How do you record a useful reproduction?

Use a beginning, action, and result. Start long enough before the failure to show the prerequisite state, perform the action once, then leave the unexpected state visible while you explain it.

An illustrative narration might be:

“I’m on the notification settings page. The current frequency is Weekly. I change it to Daily and press Save. The success message appears, but the dropdown now shows Weekly again. I expect Daily to stay selected after a successful save.”

That narration names the target and distinguishes actual behavior from your requirement. It does not decide whether the cause is a stale response, failed persistence, or a component resetting its state. Those explanations need investigation.

Pause over the target. If you say “this field,” keep the field visible and point deliberately. Moving through three panels while saying “this” leaves the reader guessing which moment carries the instruction. A clear label is useful even when pointer evidence is present.

Avoid narrating every mouse movement. Explain the actions necessary to reproduce the failure, especially actions whose significance is not obvious from pixels. “I have unsaved changes here” is more useful than “Now I move my mouse to the right.”

For the first recording, stop after the failure and expectation are clear. If you want to explore alternatives, make a separate follow-up or explicitly label the next attempt. Mixing a clean reproduction with speculative clicking makes the report harder to evaluate.

What makes expected and actual behavior different?

Actual behavior is what you observed. Expected behavior is the requirement against which you want the result judged. Both belong in the handoff, but they should not be merged.

Part of the report Illustrative example What it establishes
Starting state Frequency displays Weekly The visible value before interaction
Action Select Daily, then press Save The reported reproduction sequence
Actual result Weekly is displayed again The visible failure after the action
Expected result Daily remains selected The requested outcome
Unknown Whether the server stored Daily A question requiring investigation

“Saving is broken” is less useful because it may imply a persistence failure that the recording does not show. The UI could be displaying old data while the server stored the new value. Conversely, the UI could look correct while persistence failed. A video of the field alone cannot decide between those possibilities.

If the expected behavior includes refresh persistence, say so and test it separately. “Keep Daily visible after Save” and “Reload the page and keep Daily selected” are distinct checks. They might have the same cause, but the recording should not force Claude to invent that requirement.

This separation also helps when the issue is a product decision. If nobody has decided whether the panel should close after saving, label it a requested behavior change instead of asserting that the current behavior is a defect.

How do you connect Clipy to Claude Code?

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.

What should you check in the recording context?

Open the finished recording and review the part that matters. Check that your spoken expectation is audible and accurately represented in the transcript. Similar labels and negations deserve particular attention: “do not close” turning into “close” reverses the requested behavior.

Next, inspect the visual evidence available to the agent. Does a selected frame show the original value? Is there evidence of the changed value before Save? Can the agent see the final reset? The full video may contain all three while the extracted selection omits one. If that happens, provide the missing screenshot or direct the agent to an available relevant frame; do not assume it saw every frame.

Check the capture gaps. Pointer evidence shows what you indicated, and key moments carry click coordinates and labels. Claude inspects the repository and runtime to connect them to source.

Processing status matters too. Wait for the necessary context to finish, or explicitly limit the task to the evidence already available. A summary appearing first does not mean all visual assets are ready.

The rule is simple: the agent should state what it read and what remains missing. “I received a transcript but no usable image of the reset” is a good reason to request one additional piece of evidence.

What prompt should you paste with the recording?

Paste a prompt that asks Claude Code to tell you what it understood first, fix the bug, then verify the fix in the app and attach Clipy proof to the GitHub PR:

Use this Clipy recording to understand and fix the bug in this project. Tell me what you understood first. Verify the fix in the app and attach Clipy proof to the GitHub PR: [recording link].

What should a useful extracted bug report look like?

For our illustrative example, a concise report could look like this:

Task: Keep the selected notification frequency visible after Save.

Observed sequence:
- 00:04: Settings shows Weekly.
- 00:09: The user chooses Daily.
- 00:13: The user presses Save.
- 00:16: Weekly is visible again.

Expected behavior:
After a successful save, Daily remains selected.

Unknowns:
- Whether Daily was persisted by the backend.
- Whether a page reload changes the result.
- Whether the issue affects another account role.

Acceptance check:
Repeat the recorded sequence and inspect the selected value after Save.

Those timestamps are invented for this teaching example. A real report must use moments present in your recording. If an event cannot be located, the report should say so instead of assigning a plausible time.

Notice what is absent: no invented filename, no assumed API route, no claim that a state hook caused the reset. The report gives the agent a concrete investigation target without laundering a theory into evidence.

You can ask Claude to return this structure in the conversation. Correct any misunderstanding there before approving a change that relies on it. The bug-report recorder page is a useful starting point when you want to make the original report clearer.

How should Claude investigate without guessing the cause?

The next step is connecting observed behavior to code. Claude should locate the relevant route, inspect how the control receives and saves its value, and reproduce the sequence in an environment it is allowed to use.

Ask for evidence when the explanation becomes technical. If Claude says a response overwrites the selection, it should point to the corresponding code path and, where practical, show the runtime behavior. A recording of the reset alone does not establish that cause.

If it cannot reproduce the problem, preserve that fact. Compare environment, account role, data, viewport, and build version before changing logic. A failure present in your recording may have already been fixed, may depend on a condition you omitted, or may require a service unavailable locally.

This is where a precise unknown is useful. “I can reproduce the UI reset but cannot inspect server persistence in this environment” defines a limitation. “It should be fixed now” does not.

Keep the change proportional to the report. One failing dropdown is not a request to replace the form library or redesign the settings page. Broader work can be necessary, but it should follow from the investigation and the project’s constraints, not from the existence of a recording.

How do you review the fix against the recording?

Ask the agent to verify the change in the running app, record that verification with Clipy, and attach the proof link to the PR, showing the problem before the fix and the result after it:

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 should you do when the handoff fails?

If Claude cannot retrieve the recording, solve access first. Confirm the link, sharing state, and available integration. Do not make a private recording public merely to remove an authentication problem; use the intended authenticated reading path when needed.

If it can read only narration, supply the missing visual evidence. If it sees the interface but misunderstands the requirement, correct the expected behavior. If it understands both but cannot reproduce the bug, compare the environment and prerequisites. Each failure needs a different remedy.

For intermittent bugs, preserve the successful and unsuccessful attempts as distinct observations. Record relevant timing or state differences without asserting causation. An agent may need several observations to propose a useful experiment.

For silent recordings, write the expectation beside the link. Visible actions alone may not explain why the outcome is wrong. A panel closing could be the bug, the intended result, or irrelevant to your actual complaint.

You can judge the handoff by one question: can a reviewer identify what was observed, what was requested, and how the result was checked without reconstructing the whole conversation? If yes, the recording has become usable task context.

What do people ask about Claude Code bug recordings?

Can I give Claude Code an MP4 directly?

Check the capabilities of your specific client and installed tools instead of assuming a local MP4 is understood automatically. This guide uses Clipy’s structured recording context and supplied images. Local frame extraction is another possible workflow. Claude Code’s documented image support does not, by itself, establish how an arbitrary video file will be processed.

Do I need MCP to share a public Clipy bug recording?

No. Clipy’s documented default is the skill for public recording links. MCP is useful for authenticated library access, private recordings, and richer tool interactions. Choose the connection that matches the task; you do not need library permissions solely to read an intentionally public report.

How long should the bug recording be?

Long enough to show the necessary starting state, trigger, and result. Prefer one clean reproduction over a tour of the application. There is no universal duration that guarantees useful context. A short clip missing the prerequisite can be worse than a longer clip that clearly shows it.

Will pointer tracking identify the component that needs changing?

Pointer evidence locates the region you indicated, and key moments carry click coordinates and labels. Name the visible control in your narration and ask Claude to find its implementation in the repository.

What if Claude says the bug is fixed but the UI still fails?

Return to the original acceptance check. Ask which build and sequence it exercised, compare them with your reproduction, and show the remaining failure. A completed code edit or passing unrelated test is not enough to close a visible UI bug. Keep the report open until the intended behavior is demonstrated or the verification limitation is explicit.

Ready to use this on your own interface? Record the bug with Clipy, state the expected behavior while it is visible, and hand Claude a report you can both review.

Which sources support this workflow?

Source notes, checked September 10, 2026:

The dropdown report and timestamps are illustrative.

What if the task is a walkthrough or client feedback?

For several desired changes, use the Claude Code UI walkthrough. For a single static state, compare screenshots and recordings. When the feedback comes from a client, turn it into a clear implementation brief before changing code.