QUICK ANSWER

Record the failing flow with Clipy and explain what you expected. Give the link to your agent and ask it to write the repro or investigate the bug. You have already shown the steps on screen, so the agent can help turn that demonstration into the next piece of work.

Turn this Clipy bug recording into clear reproduction steps for engineering: [link].

The real QA tax is transcription, not testing

Here is a day most QA engineers recognize. You are grinding through a regression pass on staging, you hit a broken flow, and you reproduce it three times to be sure. The hard part is done. Then the second job starts: you open Jira, you create a ticket, and you begin retyping what you just watched. "Log in as a standard user. Go to Settings. Click the Billing tab. Change the plan to Annual. Click Save. Observe the spinner never resolves." You screenshot the frozen state, you note the browser and the build, you attach the console log, and you assign it to the engineer who owns that area.

None of that typing found the bug. It is pure transcription. You are converting something you saw into English so that someone else can convert that English back into something they can see. And the translation is lossy in both directions. You forget the exact order you clicked. You describe "the Save button" when there are two. You write "it hangs" when what you mean is a specific request that never returns. The engineer reads your paragraph, forms a slightly wrong mental model, and asks a clarifying question that costs a day of round-trip.

That round-trip is the tax. It is not that QA is slow at finding defects. It is that the handoff format, a human-written paragraph of steps, is the worst possible medium for something you already captured perfectly the moment it happened. You watched the exact reproduction. Then you threw the recording of it away and rewrote it from memory.

The fix is not "write better repro steps." The fix is to stop writing them at all, and hand engineering the recording as the repro.

The recording is the reproduction, not a video someone re-watches

The instinct against "just attach a video" is correct, and it is worth being honest about why. A raw screen recording is a bad bug artifact. It is a two-minute file the engineer has to open, scrub through, and re-transcribe into their own head, which is exactly the transcription tax again, just moved one desk over. Nobody wants to sit and watch a QA clip at 1x hunting for the moment the button failed. So teams go back to typing paragraphs, and the tax stays.

The skill retrieves the available recording context. That can include:

  • A short preamble noting that this document is meant to be read by an AI agent.
  • The recording title.
  • An AI-generated summary of what happened in the recording.
  • For a bug or feedback recording, a "Requested changes" / "Fix checklist" list, the actual repro steps and the change being asked for, extracted from what you did and said.
  • Key moments: a timestamped list where each moment has a caption, a frame image, and, where available, the on-screen coordinate of what was clicked.
  • The full timestamped transcript of anything you narrated.

Put those pieces together and you have a reproduction that reads like the ticket you would have written by hand, except you did not write it and it does not drift from what actually happened. The summary is the "what." The Fix checklist is the numbered steps. The key moments are the screenshots with the exact control marked. The transcript is your running commentary if you narrated as you went. Engineering opens one link and has all of it.

Why click-anchored key moments matter for a repro

The part that turns a decent bug report into an unambiguous one is the key moments, specifically the ones anchored to a click coordinate. A key moment is a captured instant with a caption, a still frame, and, on supported recorders, the x/y pixel of the interaction. When a moment has coordinates, Clipy burns a red-and-white marker into the frame at that exact spot. So "the Save button was broken" becomes a frame that literally has a target painted on the pixel you clicked, with a caption describing the step.

For a QA repro this is the whole ballgame. Half the clarifying questions engineering asks are "which button?" and "where exactly?" A page with two Save controls, a modal that opens over another modal, a dropdown item three rows down, these are the cases where a written step is ambiguous and a marked frame is not. The engineer does not have to guess which element you mean. It is pinned.

Click coordinates come from the Mac desktop app and the Chrome extension, which see the pointer stream directly, so record there when pinning the exact failed control matters. The extension also attaches console logs and network requests, and the Mac app records each click's accessibility label. Any Clipy recording, including one from the in-browser web recorder, carries the summary, the Fix checklist, the key-moment frames and the transcript.

Each key moment also records where its coordinate came from, so nothing is invented. The source field is click when it is a real pointer event, hover when it is inferred from where the cursor rested, or fused when signals were combined, each with a confidence value. Every marker carries its source and confidence, so you can see exactly where it came from.

How do you hand the reproduction to an agent?

  1. Record the failing flow and say what should happen instead.
  2. Copy the normal Clipy recording link.
  3. Give the link to the engineer or their coding agent.
  4. Ask for a fix and Clipy proof in the GitHub PR.
Use this recording to reproduce and fix the bug. Record the verification with Clipy and attach the proof link to the PR: [recording link].

Regression repros and flaky failures, the two hardest cases

Two categories of bug are where written repro steps fail QA the hardest, and where recording-as-repro earns its place fastest.

Regressions. A regression is "this used to work." The engineer's first question is always "are you sure, and what exactly did you do?" A recording answers both without a conversation. It shows the current build failing the flow, with the marked frame at the step that broke and the build number in your narration. When you re-run the regression pass after the fix ships, you record the same flow again; now you have a before and an after as two links, not two paragraphs you have to keep straight. For a regression suite, the recording is also self-documenting: six months later, "what was the repro for CLIP-1421" is a link that still shows exactly what failed, not a stale prose description of a UI that has since changed.

Flaky and hard-to-describe failures. The worst tickets are the ones where the failure is timing-dependent, order-dependent, or just weird, the kind you can barely put into words. "Sometimes if I click Save twice quickly the second confirmation dialog appears behind the first one" is a sentence that will get bounced back to you as "cannot reproduce." A recording of the one time it did happen, with the two dialogs captured as key-moment frames, ends that argument. You do not have to describe the indescribable. You caught it once, and the catch is the evidence. When it is truly intermittent, recording your whole test run and trimming to the moment it breaks means you never have to reproduce a flake twice just to document it.

What engineering (and its AI agent) actually receives

When the assigned engineer opens the recording context link, this is roughly the shape of what they read. This is a QA repro for a billing-save hang, on staging:

NOTE FOR AGENTS: This document describes a screen recording.
It is structured so an AI coding agent can read the reproduction directly.

# Billing "Save" hangs when switching to Annual (staging, build 4821)

## Summary
A QA tester reproduces a hang on the Billing settings page. Logged in as
a standard user on staging, they open Settings, switch to the Billing tab,
change the plan from Monthly to Annual, and click Save. The Save button
enters a loading state and never resolves; no success toast, no error.
The underlying PATCH request to /api/billing/plan is issued but no
response is observed within the recording.

## Fix checklist
- [ ] Reproduce: Settings > Billing > change plan Monthly->Annual > Save
- [ ] Save button enters loading state and never resolves
- [ ] Expected: plan updates and a success confirmation appears
- [ ] Environment: staging, build 4821, Chrome, standard (non-admin) user

## Key moments
- t=00:11 "Billing tab open, plan shows Monthly"
  frame: https://clipy.online/.../frame-0011.png  (x=642, y=318, source=click)
- t=00:19 "Plan changed to Annual in the dropdown"
  frame: https://clipy.online/.../frame-0019.png  (x=640, y=402, source=click)
- t=00:24 "Clicked Save; button shows spinner"
  frame: https://clipy.online/.../frame-0024.png  (x=712, y=468, source=click)
- t=00:41 "Spinner still active 17s later; no toast"
  frame: https://clipy.online/.../frame-0041.png

## Transcript
[00:03] Okay, I'm on staging, build 4821, standard user account.
[00:09] Opening Settings, going to the Billing tab.
[00:17] Switching the plan from Monthly to Annual here.
[00:23] And clicking Save... and it just spins.
[00:38] Still spinning, nothing came back.

The engineer reads that top to bottom in under a minute and knows the environment, the exact steps, the pixel of the Save control (x=712, y=468), and the observed-versus-expected. No re-watching, no "which Save button," no clarifying round-trip.

Now the part that is new. Because the recording context is structured plain text, engineering's AI coding agent can read it too. A developer using Claude Code, Cursor, or a similar assistant can point the agent at the recording and have it pull the summary, the Fix checklist, and the coordinate-anchored steps into context, then reason about the bug against the actual codebase. The agent reads the same repro the human did. The agent reads the reproduction as context, and the engineer's setup and prompt decide what it does next, from opening the file to proposing a fix. "The agent already has the exact steps and the failed control" is a materially better starting point than "paste your bug paragraph into the chat and hope."

What if the agent is not connected to Clipy?

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.

Where recording-as-repro fits in a QA process

This is not a call to record every ticket. Some bugs are a one-line "typo in the footer" and a recording would be overkill. Reach for a recording when the value is highest:

  • Multi-step flows where the order of clicks matters and prose gets ambiguous.
  • Regressions, where proving "it used to work, here's it failing now" saves an argument.
  • Flaky or timing-dependent failures you caught once and do not want to reproduce three more times just to document.
  • Any handoff to an engineer in a different timezone, where a clarifying round-trip costs a full day.
  • Any bug you plan to hand to an AI coding agent, where structured context beats a pasted paragraph.

Keep your ticket fields, build, environment, severity, owner. The recording replaces the one field that was always the slowest and the most lossy: the steps-to-reproduce paragraph. That is the trade. You still file a proper ticket. You just stop hand-transcribing the part you already captured.

Frequently asked questions

Does this replace our bug tracker? No. You still file in Jira, Linear, or wherever your team lives. Clipy replaces the steps-to-reproduce paragraph with a link to the recording's recording context repro. Build number, environment, severity, and assignee stay exactly as they are.

What if I record with the plain web recorder instead of the desktop app or extension? You get the AI summary, the Fix checklist, the key-moment frames and the full transcript. For repros where pinning the exact failed control matters, record with the Mac desktop app or the Chrome extension, which add click coordinates from the pointer stream.

Can our developers' AI agents actually read the reproduction? Yes. The recording context is plain structured text, and the MCP server's get_agent_context tool returns the same content as a native tool call. The agent reads the summary, steps, and coordinate-anchored key moments as context. From there, the developer's setup and prompt decide whether it edits code and proposes a fix.

Is the recording private? What do reviewers and agents see? Recording context follows the same access rules as the watch page. Share the normal link, and make sure the reviewer has access. For private recordings, ask the agent to connect your Clipy account and follow the sign-in prompt if needed.

How is this different from just attaching a video to the ticket? A raw video makes the engineer re-watch and re-transcribe, which is the same transcription tax moved one desk over. Clipy's recording context is something they read in under a minute, summary, numbered steps, marked frames, transcript, without scrubbing a timeline. And it is machine-readable, so an AI agent can consume it too.

Is it free to start, with no viewer signup? Yes. Clipy is free to start with a 7-day trial and no card, and whoever opens the link, an engineer or their agent, does not need to sign up to view the recording or read its recording context.

The takeaway

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.

Start with the free screen recorder, and read how the repro carries an escalation to engineering, how a recording gives Claude, Cursor, or ChatGPT context, and the AI-first bug report where you record once. And if you are on the other side of the handoff, filing your own bugs as a developer, here is the developer's side of this workflow.

What if someone else needs to record the reproduction?

Use a request that names the starting state, expected behavior and actions to demonstrate. Follow the request-link workflow, then review the submitted evidence before turning it into a QA report.