QUICK ANSWER
Record the interface with Clipy while you talk through your design feedback. Point to the elements you mean, show how they behave, and say what you want changed. Give the recording link to your agent and ask it to make those changes. Your walkthrough becomes the starting point for the work.
Make the design changes I explain in this Clipy recording: [link].
The ambiguity problem: design feedback loses the pointer
Here is the uncomfortable truth about the way most design feedback travels. You have a mental model that is crystal clear: you are looking at a specific element, your cursor is hovering over it, and in your head "this" is completely unambiguous. Then you translate that into a medium that cannot carry a pointer, and the clarity evaporates.
Walk through the common channels and watch where the pointer gets dropped:
Slack screenshots. A screenshot is a frozen pixel grid with no cursor state and no annotation. You paste it and write "the button here", but "here" was your finger tapping the trackpad, and the trackpad's position did not make it into the PNG. The developer sees a screen with maybe six buttons and one of them is what you meant. They pick one. Sometimes it is the right one.
"The thing on the left." Spatial language is relative, and it degrades the moment the layout changes. Left of what? On which breakpoint? After the sidebar collapses, "the thing on the left" is now the thing in the middle. Positional descriptions are a lossy encoding of a spatial fact you could have just pointed at.
Loom-style video with no anchors. Recording a walkthrough is a real improvement: the developer hears your reasoning and watches your cursor move. But a plain screen recording is a wall of pixels-over-time with no index. To find the moment you said "make this bigger," the developer scrubs. To know exactly which pixel your cursor was on when you said it, they squint at a moving cursor in a compressed video. The pointer is in there, but it is not extracted: it is not something a developer, or an agent, can read as data.
Annotation tools. Arrows, circles, and callout boxes work, but they are manual. You are re-drawing, by hand, a pointer that your own cursor already expressed for free while you were talking. It is double work, and every hand-drawn arrow is a chance to circle the slightly-wrong element.
The through-line: in every one of these, the raw pointing gesture (the thing that made your intent unambiguous in your own head) is thrown away, and the developer is asked to reconstruct it from words and a static image. Reconstruction is guesswork. Guesswork is how "make this button bigger" turns into the wrong button getting bigger, a re-review, and another round trip. The fix is not to describe the pointer better. The fix is to stop throwing it away.
How click-anchored key moments fix it
Clipy takes a different stance: instead of asking you to re-encode your pointing gesture into words or arrows, it keeps the gesture and turns it into structured data.
When Clipy processes a recording, it does not just store the video. It extracts key moments: the timestamped moments where you point at something on screen. For each key moment it produces three things:
- A frame image: exactly what was on screen at that instant.
- A full-resolution crop around the pointer position, so even on a 4K display the detail near where you were pointing stays legible.
- Click coordinates, when cursor telemetry is present: the click position as fractions of the frame's width and height. And crucially, on frames that have coordinates, Clipy burns a red-and-white marker into the frame image itself at that exact spot.
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 marker is not a caption saying "somewhere around here." It is a pixel-precise dot at the coordinate you clicked, composited into the frame. When a developer opens the key moment titled "make this button bigger," they are not reading a description of a button: they are looking at a screenshot with a marker sitting on top of the exact button. There is no "which one." The pointer that lived in your head is now a visible mark on the image.
Each key moment also carries a source and a confidence. The source tells you how the pointer position was determined: a click moment is anchored on an actual click, a hover moment on where the cursor was resting, and a fused moment combines the visual pointing gesture with the cursor telemetry for the strongest anchor. Confidence lets a consuming tool (or agent) weigh how sure the anchor is. This is explicit structure, not magic: Clipy is not guessing what you meant, it is recording where you pointed and how it knows.
Why the coordinates need the right recorder
Here is the one choice that matters: which recorder you reach for. Click coordinates and the burned-in marker come from cursor telemetry, which these Clipy clients capture:
- The Mac and Windows desktop apps.
- The Chrome extension's recordings.
So the rule of thumb is simple: for pointer-anchored frames in a design review, record with the Mac or Windows app or the Chrome extension. That is where "make this exact pixel bigger" comes from.
How to record a design review that keeps what you pointed at
This is the practical part. The whole flow takes about as long as writing a paragraph of Slack feedback, and the output is dramatically less ambiguous. Follow these steps.
- Pick the recorder that captures the pointer. Use the Clipy Mac or Windows desktop app or the Chrome extension's tab recording mode. They capture cursor telemetry, which is what produces the click coordinates and the burned-in marker. This step matters more than any other.
- Open the exact thing you are reviewing. The staging build, the Figma prototype in a browser tab, the live checkout screen: whatever the developer will actually change. Keep it in one tab or one window so the frames stay focused on the design, not your desktop clutter.
- Hit record and talk while you point. Do exactly what you would do on a call. Move your cursor to the button and say "this button should be bigger." Click on the spacing you want tightened and say "kill half this gap." Hover the label and say "wrong font weight here." You do not have to announce coordinates or draw anything: the recorder is watching your cursor.
- Point deliberately at each change. Because the pointer is the anchor, a small habit pays off: when you make a specific request, put your cursor on the element as you say it. A click is the strongest anchor (it becomes a high-confidence
click-source key moment); a deliberate hover is next. Sweeping your cursor vaguely across the whole screen while saying "clean all this up" gives the extractor less to anchor on, so be as pointed with your cursor as you are with your words. - Reverse yourself out loud if you change your mind. If halfway through you decide "actually, ignore what I said about the header: leave it," say so. Clipy's key-moment extraction handles pivots: it records the reversal and marks the earlier guidance as superseded, so nobody downstream acts on advice you already retracted.
- Stop, and let Clipy process. When you stop, Clipy transcribes the recording, writes a summary, and extracts the key moments with their frames, crops, coordinates, and markers. No watermark gets stamped on anything, and the person you send it to does not need to sign up to watch.
- Share the normal Clipy link. A developer can watch the walkthrough, and their coding agent can use the Clipy skill to read the available context. Tell the agent which design changes to implement and ask for Clipy proof in the PR.
Notice what you did not do: no screenshot annotator, no arrows, no "the thing on the left," no follow-up call to point at your screen. You pointed once, while talking, and the recording kept it.
How do you hand the review to a developer or an agent?
Send the normal Clipy recording link. A developer can watch it; their coding agent can read the available context with the Clipy skill. You do not need a different URL for each audience.
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.
Use this Clipy design review to list the changes I requested. Implement the agreed changes, then record the verification and attach Clipy proof to the GitHub PR.
Private recordings still require the right access. The agent should tell you if it cannot open the recording rather than guessing what it contains.
Where this fits in a real team's workflow
Click-anchored recordings are not only a design-review trick: they are the same primitive that makes a bug report unambiguous, and the same primitive that makes an AI-first handoff work. If your team already records walkthroughs, you have seen the adjacent versions of this idea:
- For engineering, the same "record once, hand the structured context off" model produces bug repros that write themselves: the reproduction steps and the exact element that broke come out of the recording instead of being retyped.
- For AI-assisted workflows, the pattern of recording an issue once and letting the agent read it powers AI-first bug reports where you record once and the ticket is machine-readable from the start.
- And if you want to wire a recording straight into your assistant, here is how to give Claude or Cursor access to your screen recordings over MCP.
Design handoff is just the version of this where the artifact you are pointing at is a UI you want changed rather than a bug you want fixed. The mechanism is identical: keep the pointer, extract it as data, hand it off in a form both a human and an agent can act on.
FAQ
Does this actually stop "which button?" or is it just a nicer screenshot?
It stops it, and here is the mechanical reason. A screenshot has no cursor state: the pointing gesture that lived in your head never enters the file. A Clipy key moment, on a recording with cursor telemetry, has the click coordinates and a red-and-white marker composited onto the frame at that coordinate. The element you meant is marked in the image itself, so the developer is not matching your words to a button: they are looking at the marked button.
Which recorder do I need for the click coordinates?
The Mac or Windows desktop app or the Chrome extension's tab recording. Those carry cursor telemetry, which is what produces the coordinates and the burned-in marker, so record design feedback with one of them.
What can the agent read from the recording?
It can read the available summary, transcript, and key moments, then inspect the supplied frames. Give it the normal Clipy link; the skill handles fetching that context.
Will the AI agent redesign the screen for me?
The recording gives the agent precise context for the changes you asked for, and you stay in charge of the design. What the pointer-anchored format buys you is that the agent's edits land on the right element: instead of a vague "make the button bigger," it knows the specific button you pointed at, with coordinates. You are removing ambiguity from the agent's input, which is where AI-assisted edits usually go wrong.
Do I need the MCP server, or is recording context enough?
Recording context is enough for one shared recording: the agent reads the link directly. Connect the MCP server when the agent needs private recordings or search across your whole library, using the connection guide.
Is any of this behind a paywall or a watermark?
The screen recorder, the key moments, the recording context handoff, and the agent-readable format at clipy.online/for-agents come with every plan, starting with a 7-day free trial with no card. The person you send a link to does not need to sign up to watch.
Can I review a Figma prototype or a live app, not just a static mockup?
Yes: record whatever is on screen. Open the Figma prototype in a browser tab, or the staging build, or the production app, and point at what you want changed. The key-moment extraction anchors on where your cursor was, regardless of whether the thing under it is a design tool, a web app, or your own product. Record with the Mac or Windows app or the Chrome extension so the coordinates come through.
Stop re-drawing the pointer you already made
Every arrow you draw in a screenshot annotator is you manually re-encoding a gesture your cursor already made for free. Every "the thing on the left" is a lossy description of a spot you could have just pointed at. Design feedback does not have to lose the pointer: it only loses it because the usual tools throw it away.