QUICK ANSWER

Open the interface, record your screen with Clipy, and explain the changes you want as you point to them. Give Cursor the link and ask it to make those changes in your project. You can show the spacing, interaction, or mobile layout directly instead of trying to describe every detail in text.

Make the design changes I describe in this Clipy recording: [link].

When is a recording better than a screenshot for Cursor feedback?

Use a recording when the requested change depends on an interaction, the order of steps, or a spoken explanation that points to several things. A panel that closes unexpectedly after Save is easier to explain by showing the before state, the click, and the result. A responsive menu problem often needs a view of the page before and after opening the menu.

Use a screenshot when the request is genuinely static. A misspelled heading, a wrong logo, or an unwanted border can usually be described with one image and one sentence. A recording does not make simple feedback inherently better. Choose the smallest artifact that preserves the information someone needs to act.

The distinction matters because a video can also contain too much information. A long walkthrough with unrelated navigation, repeated requests, and unfinished thoughts makes interpretation harder. You want a focused recording of one page or one connected journey, with clear statements of what is observed and what should happen instead.

For design review, the strongest combination is often a short narrated recording plus a reference image. The recording identifies the affected states; the reference establishes the desired appearance. Tell Cursor which source controls each decision. A mockup may define spacing while the recording defines interaction behavior. Neither should silently overrule the other.

What does Cursor receive from a Clipy recording?

Clipy prepares a recording for both human viewing and agent use. A person can watch the video. An agent can retrieve its structured context, including the available transcript, summary, requested actions, and prepared key moments with image evidence. Pointer and click information can help when the capture includes it. Availability depends on the recording and its processing state.

That last distinction is important. A visible cursor in a video and a structured pointer sidecar are different things. An imported recording may show a pointer without supplying the original interaction telemetry. Missing telemetry means that signal was not available; it does not establish that no interaction happened.

The agent documentation describes the public recording document and authenticated tools. Public recordings have a canonical recording context document, with recording context retained as a compatibility alias. These formats expose prepared evidence. They do not turn every millisecond of the video into an inspected frame automatically.

When Cursor uses Clipy’s MCP tools, get_agent_context can return context and prepared frame images together. A text-only retrieval of a document can instead provide image URLs that still need inspection. Ask Cursor to say whether it actually viewed the relevant image, not merely whether it found a link to one.

Cursor investigates the code in your project and connects the observed interface to its implementation, with the visual target as evidence for that investigation.

How do you connect Clipy to Cursor?

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 record before asking Cursor to edit?

Prepare the page in the state where the review begins. Use a test account and safe sample content when possible. If the problem depends on a saved preference or a particular screen width, establish that state deliberately so you can reproduce it later.

At the beginning, name the page and the purpose: “This is the account settings page. I want to review the save interaction and the mobile menu.” If the route is not obvious from the recording, put it in the accompanying prompt. A screenshot of the page does not establish which branch or environment produced it.

For each request, follow a simple spoken pattern:

  1. Identify the control using its visible label and surrounding section.
  2. Show the current appearance or behavior.
  3. Explain the desired result.
  4. State what should stay the same.

For example: “In Notification Preferences, I choose Weekly, then Save. The panel closes. Keep the panel expanded after a successful save, so I can review the other settings. Keep the existing success message.”

Pause over the relevant element while speaking. Read important text aloud. If the change involves hover, keyboard focus, loading, or error states, show those states separately. Avoid relying entirely on “this” and “there,” especially when multiple controls share the same style.

End with priorities and boundaries. “Please fix the panel behavior first. The menu adjustment is next. I am not asking for new colors or different navigation labels.” These constraints make the handoff more useful without prescribing an implementation that should be discovered from the code.

For the capture basics, see how to use Clipy. When the subject is a reproducible failure rather than a design preference, the bug-report recorder is a relevant starting point. The design-handoff guide explains the role of pointing evidence in a visual review; check which signals your recording actually captured.

What should you ask Cursor to do?

Ask Cursor to list the changes you asked for before it edits anything, then implement them and attach Clipy proof to the GitHub PR. Paste this with the recording link:

Read this Clipy design review and list the changes I asked for before editing. Then implement the agreed changes and attach Clipy proof to the GitHub PR: [recording link].

Name anything that must stay unchanged. Cursor can inspect the project to find the relevant components; you do not need to name every source file in the prompt.

What does a complete Cursor design-review example look like?

Consider an illustrative settings page with three requested changes. The timestamps below are invented for this teaching example; replace them with the real moments in your recording.

Moment What the reviewer shows What the reviewer asks
00:12 Save and Cancel use the same visual emphasis Make Save the primary action using existing button styles
00:34 The notification panel closes after Save Keep it expanded after a successful save
00:57 An open mobile menu overlaps the settings heading Keep the heading readable when the menu is open

Cursor’s first useful output is a request list, not a declaration that it knows the cause. The save behavior could involve local component state, route changes, form submission, or a shared accordion. The video does not establish which. The agent should inspect the current implementation before explaining the cause.

For the first request, a good plan identifies the project’s existing primary-button treatment. It does not introduce a new blue merely because that is a familiar primary-action color. For the second, it distinguishes a successful save from validation failure. For the third, it identifies the relevant responsive layout and asks whether the intended menu is an overlay or pushes content down if the recording does not settle that question.

You might confirm the first two requests and clarify the third: “The menu should push the content down, matching the account page. Use the existing mobile navigation pattern.” That clarification is part of the approved brief. Preserve it alongside the recording so a later session does not rediscover the same ambiguity.

Then give a bounded implementation instruction:

Implement the three approved requests using existing components and
design tokens. The mobile menu should match the account page pattern.
Keep labels, destinations, and persistence behavior unchanged.

Verify desktop Save and Cancel emphasis, successful save with the panel
still open, validation failure, and the mobile menu at the recorded size.
Report what you actually checked and anything you could not exercise.

The useful outcome is a reviewable diff connected to those checks. A clean build is supporting evidence, but it cannot show whether the mobile heading remains visible. The running interface needs inspection at the relevant state and size.

How do you review the changes without repeating the walkthrough?

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 if Cursor reads the words but misses the design?

First, inspect retrieval rather than rewriting the whole prompt. Did Cursor receive the transcript? Did it inspect image evidence? Is the relevant moment available? A summary that mentions a button does not prove that the model saw its position or styling.

If frames are still preparing, wait until the relevant evidence is available. If a prepared frame does not show the state you need, add a screenshot or a short follow-up recording.

If the agent points to the wrong control, provide the visible label, section name, and timestamp. For duplicate labels, describe the relationship: “The Save button at the bottom of Notification Preferences, not the account-profile Save button.” This is often enough to resolve the target without naming a source file yourself.

If Cursor chooses the wrong implementation area, ask it to trace the route and component ownership in the repository. Shared components can appear on several pages, and a global style change can affect more than the screen you recorded. The scope of the code change deserves independent review.

If MCP is missing, check that the server is enabled and that Cursor was restarted after configuration. Review MCP logs for connection and authentication errors. Cursor documents these diagnostics and notes that image analysis depends on a model that supports images. Cursor MCP troubleshooting and image context

How does this differ from annotations and bug-reporting tools?

Clipy covers all three kinds of evidence in one place: annotated screenshots for a static target, narrated recordings for behavior and sequence, and, from the Chrome extension, console logs, network requests and GraphQL errors for runtime evidence. Annotation-only tools capture a static target, and diagnostics-only tools capture browser data without your explanation. Clipy keeps the explanation, the sequence and the diagnostics together in one link that people and Cursor read from the same source.

There are also tools specifically for converting existing client videos into prompts. The creator of Video2Prompt described that workflow in Cursor’s forum after receiving several client recordings. That is a useful example of someone building for the problem, not a survey proving demand or a comparative performance result. Creator’s Cursor forum post

Use an annotated screenshot for a simple visual target and a recording for behavior and narration, both in Clipy, and let the Chrome extension attach runtime evidence when the investigation needs it. Give Cursor the link, and it gets the evidence relevant to the requested change.

What are the common questions about sending recordings to Cursor?

Can I send an MP4 directly to Cursor?

The answer depends on the Cursor surface, model, and tools available in your session. This guide uses Clipy’s prepared text and image evidence rather than assuming direct MP4 analysis. Verify what the session actually loaded before relying on its interpretation of the video.

Do I need MCP for one public recording?

Not necessarily. A public Clipy recording has an agent-readable document that a suitably equipped agent can fetch. MCP is useful for authenticated access, library tools, and returning prepared images inline. Either way, confirm successful retrieval rather than treating a pasted URL as a completed handoff.

Does Clipy tell Cursor exactly which source file to edit?

No automatic mapping should be assumed. Clipy supplies recording evidence. Cursor must inspect your project, find the relevant route and components, and justify the proposed change. A coordinate or frame can identify a visual target without identifying the source file that owns its behavior.

Can I use the same recording for Claude Code or Codex?

Yes, the recording context is not inherently tied to Cursor. The setup and available tools vary by agent. See Clipy for Claude Code and the agent integration guide. Keep the same approved request list so switching agents does not silently change the task.

Is a public recording suitable for confidential client feedback?

Treat a public recording link as accessible to people who receive it. Check the recording’s actual access rules and your client’s requirements before sharing. Use safe sample data where possible, and do not assume that your authenticated Cursor session makes a public link private.

To try the workflow, choose one visible issue in your current project. Record the feedback with Clipy, ask Cursor to restate the requested change with evidence, and compare the resulting interface against that request.

How do you handle feedback from a client?

Use the client-feedback brief to separate the requested change, acceptance criteria and open questions. If you need the client to record first, the request-link guide explains that collection step.