FOR QA
Generate Playwright Tests from a Screen Recording
An agent-readable screen recording turns one manual test run into a Playwright suite. Clipy captures every click with its target and coordinates, and your narration becomes assertions — so the agent writes selectors from what you actually did, not guesses.
The whole loop in under a minute. Tap for sound.
One recorder, every workflow
Clipy is for every use case
Same loop, whatever your team does: record once, share one link, and an AI agent reads it and acts. Switch roles to see it play out.
Agent-ready fast
Chunks stream to the server while you record, so the moment you stop the summary, key-moment frames, and transcript are already building — a short clip is agent-ready in seconds.
Our own pipeline
On-device transcription and key-moment fusion we built ourselves — not a third-party API bolted on — tuned for speed and for the exact context an agent needs to act.
Fastest agent loop
The fastest agent-ready screen recorder: one link a teammate watches and an AI agent reads. No ticket, no repro write-up, no re-explaining.
A recorded bug is a dead end — twice
You run the manual test, record the bug, and drop the MP4 in the ticket. Engineering bounces it — “can’t reproduce, what did you click?” The video shows a cursor drifting across the screen but never which element it hit: no selector, no state, no timing. Then the fix lands and you owe a regression test, so you run the exact same flow a second time and hand-translate it into code, guessing selectors off the DOM. One manual run, and you pay for it twice.
How it works
- 1
Run the test once
Click through the happy path and say the checks out loud — “badge should show one.”
- 2
The agent reads the run
Each interaction arrives with its click target and frame; each spoken check becomes an assertion candidate.
- 3
Get the suite
checkout.spec.ts generated from the captured interactions, run across chromium, firefox, and webkit.
Selectors resolved from the element you clicked, not guessed from pixels
Agent-written tests are usually brittle for one reason: the agent is staring at a screenshot and inventing a selector — an nth-child chain, a raw coordinate, an XPath that shatters on the next render. It never saw the DOM, so it guesses.
An agent-readable screen recording removes the guess. On Mac-app and Chrome-extension recordings, Clipy captures each click with its real target — button#add-to-cart, not a point 84 percent across the frame. The agent resolves the selector from the element you actually hit, in the order you hit it.
Real target, not a bounding box
Each click carries the element itself — button#place-order — so the test keys off a stable selector instead of a pixel that moves the moment the layout shifts.
The click order is the script
Interactions land in sequence with timestamps, so the spec walks the flow exactly as you ran it — no reassembling steps from a pile of screenshots.
Frames to disambiguate
Every key moment carries its extracted frame, so when two elements look alike the agent has the image too — text and images, the only two formats an agent reads.
Say the check out loud and it becomes an assertion
Clicks are the easy half. The hard half is knowing what to assert — a screenshot can’t tell an agent what “correct” looked like. Your voice can.
Narrate the expected state as you test — “cart badge shows one,” “confirmation page, the order number appears” — and each check lands in the timestamped transcript, pinned to the moment you said it. The agent maps the words to the interaction right before them and writes the assertion: the badge should read 1, the URL should reach the confirmation route. You aren’t writing Gherkin or filling a template. You’re doing the manual test you already do, and talking the way you already talk while you do it.
One recording, two jobs — a repro that doesn’t bounce and a suite that lasts
The same agent-readable screen recording pulls double duty. Before the fix it’s the bug report engineering can’t send back: the exact click sequence, the timing between steps, and the real target at each one, instead of “it was somewhere around here.” After the fix, that same recording is the source for the regression test — the thing you did to prove the bug becomes the thing that proves it stays fixed.
A repro they can’t bounce
Click sequence, timing, and the element hit at each step. Engineering reads what happened instead of scheduling a call to watch you do it again.
Evidence that outlives the ticket
The recording stays as the source of truth. When the UI changes, re-record the flow once and regenerate the spec instead of hand-patching selectors one by one.
Green on all three engines
The agent runs the generated suite across chromium, firefox, and webkit, so a flow that passed on your machine is checked on every engine your users run.
One checkout run becomes checkout.spec.ts
A tester runs the checkout happy path on staging — amazio.com/checkout — with Clipy recording. They add the headphones to the cart and say “badge should show one.” They place the order with the test card and say “confirmation, the order number appears.” They hit stop, and because chunks stream while recording, a short clip like this is agent-ready in seconds. The document arrives with four key moments — a click at button#add-to-cart, the cart-badge frame, a click at button#place-order, the confirmation screen — and the transcript carrying both spoken checks. Their coding agent reads the link and generates checkout.spec.ts from the captured interactions: selectors resolved from the click targets, four assertions inferred from the narration, run across chromium, firefox, and webkit. Green on all three. The tester clicked through the flow once; the suite is permanent.
Selectors from real clicks
The agent keys tests off the element you actually clicked — button#add-to-cart — not a guess scraped from a screenshot, so the spec doesn’t break on the next re-render.
Assertions from your narration
Say the expected outcome while you test and it becomes an assertion candidate, mapped to the exact interaction — “badge should show one” turns into a check on the cart count.
A repro engineering can’t bounce
The click sequence, timing, and target at each step land as a document a developer reads directly — no “can’t reproduce,” no call to re-run the flow live.
Agent-ready in seconds
Chunks stream to the server while you record, so a short manual run is agent-ready in seconds — the fastest agent-ready screen recorder feeding your test-writing agent, and free.
The manual run, two ways
| The old way | With an agent-readable recording | |
|---|---|---|
| Filing the bug | MP4 in the ticket; engineering replies “can’t reproduce, what did you click?” | Click sequence, timing, and the real target at each step — a repro they read, not one they re-run. |
| Selectors | Agent guesses from a screenshot — nth-child chains and XPaths that break on the next render. | Resolved from the element you clicked — button#place-order, a stable target. |
| Assertions | You write every check by hand after the fix lands. | Inferred from what you narrated — “badge should show one” becomes a check on the cart count. |
| Writing the regression test | Run the flow a second time and translate it into code yourself. | One run generates checkout.spec.ts — the manual test and the automated test are one take. |
| Cross-browser | You configure and run chromium, firefox, and webkit yourself. | The agent runs the generated suite on all three and reports pass or fail. |
Common questions
Can I generate Playwright tests from a screen recording without hand-writing selectors?
Yes. On Mac-app and Chrome-extension recordings, Clipy captures each click with its real target, so the agent resolves selectors from the elements you clicked rather than inventing them from a screenshot. You run the flow once; the agent writes the spec.
Will the recording work as a bug report engineering can actually reproduce?
That’s the point. The agent-readable screen recording carries the exact click sequence, the timing between steps, and the element hit at each one — so a developer reads what happened instead of replying “can’t reproduce.” The same recording later seeds the regression test, so the repro and the test come from one run.
Which recordings capture click targets and coordinates?
The Mac app and the Chrome-extension tab recordings capture clicks with their targets and coordinates. Those are what let the agent resolve selectors and crop frames to the button you hit. A plain capture without a click track still gives the summary, frames, and transcript — you just lose the exact target metadata.
What happens to the generated tests when the UI changes?
Re-record the flow once and regenerate the spec. Because the selectors come from the live elements at record time, a fresh recording produces fresh selectors — you replace the take instead of hand-patching every locator that drifted.
Can the agent add assertions I didn’t say out loud?
Your narration is the source for behavioral checks — the outcomes you actually care about. The agent can also add structural checks it sees in the interactions, like reaching the confirmation route, but the reliable, intent-level assertions come from what you narrated. Say the check and you get the assertion you meant.
How fast is a recording ready for my agent to read?
Chunks stream to the server while you record, so the summary, key moments, and transcript are already building as you go. A short clip is agent-ready in seconds — best case under about 10 seconds — which is what makes it the fastest agent-ready screen recorder for a test-writing loop.
Can I generate API or unit tests this way, or only UI flows?
This is for UI flows you click through — the recording captures on-screen interactions, so it maps cleanly onto browser tests like Playwright. API and unit tests aren’t derived from a screen recording; use it for the end-to-end paths a human tests by hand.
Do I need to install anything, and is it free for the team?
For public recordings, install the Clipy skill once and any clipy.online/video link resolves to its markdown twin — no API key. For private recordings or library search, use the Clipy MCP server (@clipy/mcp). Recording, transcripts, key moments, and the documents are all free, with no viewer sign-up.