QUICK ANSWER
Show the feature you want by recording your screen with Clipy. Walk through the current flow, point to what should change, and explain the outcome. Give the link to your coding agent and ask it to help build that change. The recording carries the context you would normally explain in a walkthrough.
Use this Clipy walkthrough to help implement the feature I describe: [link].
The real cost of the written ticket
Think about what a feature ticket is actually trying to do. It's compressing a spatial, temporal, opinionated thing: "when the user does this, in this part of the screen, the app should behave like that instead": into linear text. That compression is lossy, and the lossiest parts are exactly the ones that matter for implementation:
- Which element. "The save button" is fine until there are three save-like buttons on the page. Prose can't point.
- Where it should go. "Move it up near the title" means a dozen different pixel positions to a dozen different readers.
- Why. The reasoning behind a change ("users keep missing this because it's below the fold") rarely survives the trip into a ticket, and it's the reasoning that tells the implementer what "done right" means.
Engineers have coped with this forever by asking follow-up questions, and that loop was tolerable when a human was on the other side. But an AI coding agent doesn't ping you on Slack to clarify. It fills the gaps with assumptions, writes code against those assumptions, and hands you a diff that's technically responsive to the ticket and completely wrong about intent. Now you're reviewing a confidently incorrect PR, which is arguably worse than a blank one.
The written ticket isn't broken because writing is hard. It's broken because you're using the wrong medium to describe a visual, interactive change to a reader (human or machine) who needs to know exactly what you were looking at.
Why a recorded walkthrough beats a written ticket for AI-assisted teams
A screen recording where you talk over what you're doing carries the three things a ticket loses. You point the cursor at the actual element, so "which one" is unambiguous. You demonstrate the flow in order, so the sequence is captured, not reconstructed. And you narrate your reasoning as you go, because that's just how people talk when they're showing someone a thing.
The obvious objection: "a video isn't a spec, it's a video: the engineer still has to watch it, take notes, and translate it into work." That's true of a plain screen recording, and it's the reason "just send a Loom" never fully replaced the ticket. A raw video is a wall you have to scrub through. It's not searchable, not linkable to a line of code, and definitely not something you can drop into a coding agent's prompt.
Record the process, narrate the important steps, and give your agent the normal Clipy link. Ask it to use the Clipy skill to draft the SOP and flag anything the recording leaves unclear. You demonstrate the process; the agent prepares the draft for review.
Clipy is a screen recorder built around this idea: the recordings are meant to be read by AI agents, not just watched by people. The full picture of what agents receive lives at clipy.online/for-agents.
What the recording context actually contains
Give the agent the normal Clipy recording link:
- A note-for-agents preamble. A short header telling any AI reader what this document is and how to use it, so an agent that stumbles onto it knows it's context, not prose to summarize.
- The title and a summary. A plain-language description of what the recording covers, generated from the transcript and the visuals.
- A "Requested changes" list. This is the part that matters most for a PM handoff. Clipy pulls out the asks you voiced during the walkthrough ("this button should move here," "this flow should validate before submitting") into a discrete list. That list is your acceptance criteria, extracted from you talking instead of you typing.
- Key moments. Timestamped points in the recording, each with a frame image. For recordings that captured clicks, each key moment carries the click coordinates as fractions of the frame, a full-resolution crop around the pointer, and a source label (fused, click, or hover) plus a confidence score. The frames tied to a coordinate get a red-and-white marker burned into the image at the exact spot you clicked. So the agent doesn't just know "the user clicked something around here": it gets a picture with a target painted on it.
- The transcript. The full text of what you said, so nothing you narrated is lost.
That structure is deliberately friendly to a coding agent. The summary orients it, the Requested-changes list gives it the work, the key-moment frames with coordinates anchor each request to a specific spot in the UI, and the transcript is there when it needs the exact words. It reads like a spec because it's shaped like one.
Which recorders capture clicks
The click-anchored part is the differentiator. Click coordinates and the pointer crops come from the Clipy Mac and Windows apps and the Chrome extension when it records a browser tab, which track where your cursor is relative to what's on screen.
For a feature handoff, record with one of them, and narrate precisely ("the blue Save button in the top-right of the editor") so your words and the coordinates point at the same thing.
How a PM records a feature handoff, step by step
The mechanics are short on purpose. The goal is a two-to-three-minute recording, not a polished demo.
- Open the actual screen you're describing. The live app, a staging build, a Figma prototype, whatever surface the change lives on. You want to point at real UI, not a mockup in your head.
- Pick a recorder that captures clicks. Use the Clipy Mac or Windows app or the Chrome extension in tab mode so your clicks get coordinate-anchored.
- Talk the way you'd talk to an engineer sitting next to you. Move the cursor to the element, say what it is, say what should change and why. "This is the current submit button. It should move up next to the title, and it should be disabled until the form is valid, because people keep submitting empty." Point, then explain. Every time you say "this" while pointing, you're giving the recording a coordinate to anchor.
- Demonstrate the flow in the order it happens. If the change spans two screens, walk both in sequence. The key-moment extraction follows your path, so a coherent order produces a coherent spec.
- State your asks explicitly. The Requested-changes list is built from what you voice, so phrase the important ones as clear requests: "So the change I want is X." Vague musings are harder to extract than a plainly stated ask.
- Share the normal Clipy recording link with your agent. The skill handles retrieving the available recording context.
That's it. No writing. The forty-five-minute ticket becomes a ninety-second recording plus a ten-second URL edit.
What should the PM ask the agent to do?
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.
Read this Clipy feature walkthrough and list the requested changes before editing. Implement the changes we agree on, verify them, and attach Clipy proof to the GitHub PR: [recording link].
Call out priorities, non-goals, and decisions that still need a person. The agent can inspect the project for implementation details; the PM supplies the intended outcome.
Where this fits in a real workflow
You don't have to replace every ticket with a recording. The recorded-walkthrough handoff earns its keep on exactly the tickets that are hardest to write and easiest to misread: UI changes, flow changes, "move this, gate that, reorder these" work, and anything where the ask is inherently about what's on screen. For a one-line backend config change, type the ticket. For "here's how I want this whole onboarding flow to feel," record it.
The through-line is that spatial, interactive intent should be captured spatially and interactively, then made readable, rather than flattened into prose and re-inflated by whoever reads it. For a team handing work to AI coding agents, that's not a nice-to-have. It's the difference between an agent that implements what you meant and one that implements what it guessed.
FAQ
Does the AI coding agent actually build and ship the feature by itself?
No. The agent receives a precise spec and, with repo access, can implement the mechanical parts against the right files and elements. You still review the diff, make the judgment calls, and decide when it's done. Clipy gives your agent the full context to ship the feature.
Does Clipy integrate with Jira or Linear?
Yes. Clipy creates a Jira, Linear or GitHub issue straight from a recording, with the recording attached, and can publish a Confluence page. The same recording also works as a readable spec for your agent through the recording context URL and the MCP server.
Which recorder do I need for the click coordinates?
The Mac or Windows app, or the Chrome extension recording a browser tab. Those capture where you clicked, so the key-moment frames get coordinate-anchored with a marker burned into the image.
What's the difference between the recording context URL and the MCP server? The recording context URL gives an agent one recording as a document, with no setup. The MCP server connects your account, so the agent can read private recordings and search your whole library. The connection guide covers setup.
Do the engineers or the agent need a Clipy account to read the recording? A public recording is readable with its normal link. Private recordings and library search need the right Clipy account access. Ask the agent to handle the connection if needed.
How much does this cost?
It is free to start. The screen recorder, the recording context spec export, and the MCP server are included on every plan, starting with a 7-day free trial with no card, and viewers never need to sign up. You can start recording from clipy.online/screen-recorder and read more about what agents receive at clipy.online/for-agents.
How long should the handoff recording be?
Two to three minutes is the sweet spot for a single feature. Long enough to point at each element and state your asks, short enough that the summary and Requested-changes list stay tight. If a change spans several unrelated screens, consider one recording per logical chunk rather than a fifteen-minute marathon.