You reviewed the new checkout screen, opened Slack, and typed: "make this button bigger and move the thing on the left up a bit." You attached a screenshot. Three messages later the developer replies: "which button?" Now you are drawing arrows in a screenshot annotator, or worse, hopping on a call to point at your own screen with a shared cursor nobody can find.

Design feedback dies in ambiguity. Not because designers are vague on purpose, but because the tools we use to hand off intent throw away the one thing that made the feedback unambiguous in the first place: where you were pointing. This post is about a recording format that keeps it — and hands the exact pixel you clicked to a developer, or to an AI coding agent, without you drawing a single arrow.

TL;DR

  • Design feedback is ambiguous because screenshots and phrases like "the thing on the left" strip out where you were pointing. The developer has to reconstruct your intent, and reconstruction is where the wrong button gets resized.
  • Clipy records your design review and extracts key moments — the timestamps where you point at something. Each key moment has a frame image, a full-resolution crop around the pointer, and, when cursor telemetry is present, the exact click coordinates with a red-and-white marker burned into the frame at that spot.
  • So "make this button bigger" stops being ambiguous: the key-moment frame captures the exact pixel your cursor was on. The developer sees the marker on the exact button — there is no "which button?"
  • Click coordinates only exist for recordings made with the Mac desktop app or the Chrome extension's recordings — those carry cursor telemetry. A plain web-recorder capture still gets a summary and transcript; it just may not have the pointer-anchored coordinates.
  • Append .md to any watch URL (https://clipy.online/video/<id>.md) to hand that same pointer-anchored context — summary, key-moment frames with coordinates, transcript — to a developer's AI coding agent in plain text.
  • For a deeper integration, the Clipy MCP server (npx -y @clipy/mcp) lets an agent pull the frames as inline images with one tool call. See clipy.online/for-agents for the whole agent-readable story.
  • Everything is free: no watermark, no viewer signup.

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.

That last detail is the whole point, so read the differentiator slowly: with Clipy, "make this button bigger" isn't ambiguous — the key-moment frame captures the exact pixel your cursor was on (click coordinates burned into the image), and appending .md hands that same pointer-anchored context to a developer or an AI coding agent.

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 honest 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 caveat to be crisp about, because it changes which recorder you should reach for. Click coordinates and the burned-in marker only exist when the recording carries cursor telemetry, and that telemetry is captured by two of Clipy's clients:

A plain capture from the in-browser web recorder still gets you the good stuff — a summary, key-moment frames, and a full transcript — but it may not have the pixel-precise click coordinates and marker, because it does not always carry the underlying cursor telemetry. So the rule of thumb is simple: if you want the pointer-anchored frames for a design review, record with the Mac app or the Chrome extension recording. 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.

  1. Pick the recorder that captures the pointer. Use the Clipy Mac desktop app or the Chrome extension's tab recording mode. Both capture cursor telemetry, which is what produces the click coordinates and the burned-in marker. This step matters more than any other — the plain web recorder will still record a fine walkthrough, but it is the one path that may skip the pointer coordinates.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. Grab the watch link and share it. That link is your handoff. A developer can watch the walkthrough and jump straight to any key moment. And — this is the part the next section is about — the same link plus .md is a machine-readable handoff for an AI coding agent.

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.

Handing off: to a developer vs. to an AI agent

A finished Clipy recording is a handoff artifact with two audiences, and it serves both from the same URL.

To a developer: the watch page

Send the developer the watch link. What they get is not a wall of video — it is an indexed review. The summary tells them the gist. The key-moment strip lets them jump to "make this button bigger" without scrubbing, and when they land there, the frame has the red-and-white marker sitting on the exact button, with a full-resolution crop so they can see the detail even if the recording was a 4K display. "Which button?" is answered before it is asked. The developer implements against a pointer, not a paraphrase.

To an AI coding agent: append .md

This is where the format earns its keep in an AI-assisted workflow. Take any Clipy watch URL and append .md:

https://clipy.online/video/<id>.md

That returns a plain-text, machine-readable version of the recording: the summary, the key-moment frames with their coordinates, and the full transcript. It is designed to be dropped straight into a developer's AI coding agent — Claude, Cursor, whatever they use. The agent does not have to watch a video or interpret a screenshot; it reads structured context in which each pointing moment says, in effect, "at this timestamp the reviewer pointed here (x, y), and said this." As the endpoint itself documents it, the coordinates are the click position as fractions of frame width and height, and the frames with coordinates have a marker burned in at that spot — so the anchor survives the trip from image into text.

Be clear about what this does and does not claim. The agent does not "redesign the screen for you." What it receives is unambiguous, pointer-anchored context: instead of a vague "make the button bigger" that it has to map onto some button by guessing, it gets the specific element you pointed at, with coordinates, so its edit lands on the right thing. You are removing the ambiguity from the agent's input, which is exactly the failure mode that makes AI-assisted edits touch the wrong component.

The .md endpoint obeys the same access rules as the watch page — if a person cannot open the watch link, neither can their agent. Nothing about appending .md makes a private recording public.

The deeper path: the Clipy MCP server

If the developer's agent supports the Model Context Protocol, there is a tighter integration than pasting a URL. The Clipy MCP server runs with:

npx -y @clipy/mcp

and a CLIPY_API_KEY from clipy.online/settings/api-keys. It exposes a get_agent_context tool that hands the agent the same summary, transcript, and key moments — but with the frames as inline images, so a multimodal agent can literally look at the marked frame rather than just read its coordinates. The design review becomes something the agent can both read and see, anchored on the pixel you pointed at. The full agent-readable story, including this MCP path, lives at clipy.online/for-agents and in the MCP overview.

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:

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 desktop app or the Chrome extension's tab recording. Those carry cursor telemetry, which is what produces the coordinates and the burned-in marker. A plain in-browser web-recorder capture still gives you a summary, key-moment frames, and a transcript, but it may not include the pixel-precise click coordinates. If pointer-anchored frames are the whole reason you are recording, use the Mac app or the extension recording.

What exactly does appending .md give me?

Append .md to any watch URL (https://clipy.online/video/<id>.md) and you get a plain-text, machine-readable version of the recording: the summary, the key-moment frames with their coordinates, and the full transcript. It is meant to be handed to a developer's AI coding agent so the agent works from unambiguous, pointer-anchored context instead of guessing which element you meant. It respects the same access rules as the watch page.

Will the AI agent redesign the screen for me?

No — and we would rather be straight about that than oversell it. The agent receives context, not a finished redesign. 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 .md enough?

The .md URL is enough for most handoffs — paste it into the agent and go. The MCP server (npx -y @clipy/mcp, with a key from settings/api-keys) is the tighter path: its get_agent_context tool delivers the frames as inline images, so a multimodal agent can look at the marked frame directly. Use .md for quick handoffs, MCP when you want the agent to see the frames.

Is any of this behind a paywall or a watermark?

No. Recordings have no watermark, and the person you send a link to does not need to sign up to watch. The screen recorder, the key moments, the .md handoff, and the agent-readable format at clipy.online/for-agents are all free to use.

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. Just remember to record with the Mac app or the Chrome extension recording 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.

Record the review with the Clipy Mac app or the Chrome extension recording, point at what you mean while you talk, and hand off a link. The developer gets a marked frame; the AI agent gets the same pointer-anchored context by appending .md. "Make this button bigger" finally means this button. Start at clipy.online/for-agents or grab the recorder and try it on your next handoff.