Turn a Screen Recording Into an SOP (Record Once, Agent Writes It)

You just did the thing. You walked through the whole process — opened the dashboard, filtered the right report, exported the CSV, dropped it in the shared folder, pinged the channel. It took four minutes. And now someone wants it written up as a standard operating procedure so the next person can do it without asking you.

So you sit down to write. And you realize you have to reconstruct a thing you just did fluently: what did I click first, what was that menu called, which of the three export buttons was the right one, what did I type in the filter box. You end up re-doing the process slowly, half in the app and half in a doc, screenshotting as you go and pasting "then click the blue button in the top-right" like it's 2015.

There is a better order of operations. Record the process once while you narrate it out loud. The recording already captured every click, every screen, and every word you said. Then — this is the part no other recorder does — append .md to the recording's link and hand that to an AI agent. The agent reads a structured document (summary, timestamped transcript, and click-anchored key-moment frames) and writes the numbered SOP for you. You did the process. The recording documented it. The agent typed it up.

This post is the practical version of that: how to record a process so it converts cleanly into an SOP, how the .md is structured, and the exact prompt to hand your agent.

TL;DR

You don't retype the process. You perform it once while narrating; Clipy captures the screen, your voice, and (on the Mac app and Chrome recordings) the cursor and clicks. The recording is the raw material for the SOP.
Every recording has a Markdown twin. Append .md to the watch URL — https://clipy.online/video/<id>.md — and you get a summary, a timestamped transcript, and timestamped key moments, generated automatically, free.
Key moments are click-anchored. For cursor-capturing recordings, each key moment carries the click coordinates as fractions of the frame plus a cropped, marker-burned frame — so an agent can write "click the Export control in the top-right toolbar" instead of guessing which button you meant.
An AI agent writes the SOP from the .md, not you. Paste the copy-paste prompt below, hand over the .md (share the link, or wire up the MCP server), and you get numbered, imperative SOP steps back.
Honesty up front: Clipy does not have a one-click "generate SOP" button and there is no auto-published SOP page. The flow is record → .md → an agent turns it into the SOP. That's the whole trick, and it's enough.
Everything's free: recorder, transcript, summary, key moments, .md, and MCP. No watermark, no viewer signup. See clipy.online/for-agents for the agent-readable side.

Why writing SOPs from scratch is the wrong order

A standard operating procedure is just a process someone did, written down so someone else can repeat it exactly. The information content of a good SOP is almost entirely in the doing: the sequence of screens, the specific controls, the values you type, the decisions you make at each fork. When you write an SOP from a blank page, you're trying to recall all of that from memory — and memory is exactly the wrong source. You skip the step you do on autopilot. You mislabel the button. You forget the modal that pops up the first time.

The people who write SOPs for a living know this, which is why the good ones record themselves first. But recording has historically only moved the problem: now you have a four-minute video, and turning a video into written steps means someone sits and re-watches it, pausing every few seconds to transcribe "okay, now they click Settings." A screen recording is not a document. A human still has to convert it.

The right order flips the labor. You record the process once, narrating as you go — which you can do at full speed because you're just describing what you're already doing. Then the conversion from recording to written steps is handled by an AI agent reading a structured version of the recording. You never re-watch the video. You never retype the process. The recording is the primary source, and the agent is the transcriptionist that turns it into an SOP.

The only reason this works is that Clipy doesn't hand the agent a video. It hands it a .md.

What the `.md` actually contains (the raw material for an SOP)

Take any recording's watch link and append .md:

https://clipy.online/video/abc123        ← the video you watch
https://clipy.online/video/abc123.md     ← the document an agent reads

There is no conversion step and no "export" button — the .md is generated for every recording and served live. It obeys the same access rules as the watch page: a public recording's .md is readable by anyone with the link; a private one needs a signed-in session. Here's what's inside, in the order it appears, and why each part matters for an SOP:

The NOTE-for-agents preamble and title

The document opens with a short note addressed to the agent reading it — a plain-language heads-up that this is a machine-readable representation of a screen recording, followed by the recording's title. It's there so an agent that fetches the URL cold knows what it's holding before it starts reasoning.

The summary

A generated prose summary of what happened in the recording. For SOP work this is your outline: it's the "what is this process, at a glance" that becomes the SOP's purpose line and scope. It's also the fastest sanity check that your narration landed — if the summary describes the process you meant to demonstrate, the rest of the document will too.

Requested changes (feedback)

If feedback has been left on the recording, the .md surfaces it as a "Requested changes" section. For an SOP this is where a reviewer's "add the approval step before export" note travels alongside the raw material, so the agent writing the SOP can fold corrections in on the next pass.

Key moments — the click-anchored spine of the SOP

This is the section that makes a recording into an SOP instead of a transcript. Key moments are a timestamped JSON array — each entry has a timestamp, and depending on the recording, a rendered frame, a full-resolution crop around the pointer, and the click coordinates expressed as fractions of the frame (so they're resolution-independent). Each moment also declares its source — fused, click, or hover — and a confidence value, so a careful agent can weight a high-confidence click over an inferred hover. For coordinate moments, the frame has a red-and-white marker burned into it at the click point.

Concretely, that means the raw material for "Step 3" isn't a vague sentence — it's a timestamp, a cropped image of the exact control you clicked with a marker on it, and the fractional coordinates of that click. An agent turning this into an SOP can write a step that names the control and points to precisely the right spot, because the recording told it precisely where you pointed.

The transcript

The full timestamped transcript of your narration. This is the language of the SOP: the verbs you used, the names you gave the buttons, the "and make sure you pick the last-30-days range, not the default" asides that turn a mechanical click list into an actual procedure. The transcript and the key moments share a timeline, so the agent can line up "what I said" with "where I clicked" and produce steps that read like a person wrote them.

Click coordinates, honestly: which recordings have them

Click coordinates and the pointer crops are only captured on the Mac desktop app and the Chrome extension's tab recordings. The web recorder produces a full summary and transcript, but no click coordinates. I'm stating this plainly because it changes how you record an SOP.

For an SOP, the coordinates genuinely help — they let the agent write "click the control at the top-right of the toolbar" and back it with a cropped frame, instead of relying on your narration alone to identify the button. So if the process you're documenting is a desktop or in-tab workflow and you want the tightest, least-ambiguous steps, record it with the Mac app or the extension's recording. If you're capturing a multi-window desktop flow or something outside a single browser tab, the Mac app is the one that gives you coordinates.

If you only have the web recorder, you still get a perfectly usable SOP — the transcript plus the summary carry the process, and a well-narrated recording ("now I'm clicking the blue Export button in the top-right") gives the agent the control names it needs. You just lean harder on narration to replace what the coordinates would have supplied.

How to record a process for an SOP (narrate every step, point deliberately)

The quality of the SOP is set here, at record time. The agent can only write from what the recording captured, so a clear, narrated, deliberate recording produces a clear SOP and a mumbled one produces mush. Here's the flow that converts cleanly.

Pick the recorder that matches the process. Desktop or multi-window workflow → Mac app (you get click coordinates). A single browser-tab workflow → the Chrome extension's recording (also coordinates). Quick web-only capture where you're comfortable carrying the steps in narration → the web recorder. Start from clipy.online/screen-recorder.
Do a ten-second dry run first. Before you hit record, walk the process once silently so you don't fumble on camera. An SOP recording should be one clean pass, not a blooper reel — the summary and steps are cleaner when the recording is.
Say what the process is in the first sentence. Open with "This is how to export the weekly usage report and post it to the finance channel." That one line seeds the summary, which becomes the SOP's title and purpose. Name the audience if it matters ("this is for anyone on the ops rota").
Narrate each step as an instruction, not a description. The trick is to talk in the imperative, the way the SOP will read: say "click Reports in the left sidebar," not "so I'm gonna go over here." You're basically dictating the SOP while you perform it. The agent will lift your phrasing almost verbatim.
Point deliberately before you click. Move the cursor to the control, pause for a beat, then click. On coordinate-capturing recordings this gives the key-moment extractor a clean click to anchor, and the burned-in marker lands on the right control. Don't fly the cursor around — a deliberate point is a better anchor and a clearer frame.
Name every control out loud, even the obvious ones. "Click the Export button." "Choose CSV from the format dropdown." "Set the range to Last 30 days." The control names are what turn coordinates into a readable step. On the web recorder, where there are no coordinates, this is doing double duty — it's the only source of control names.
Call out the decisions and the gotchas. SOPs live and die on the forks. "If the export is over 10 megabytes, use the compressed option instead." "Make sure you're in the production workspace, not staging — check the top-left." Say these out loud; they become the SOP's conditional steps and warnings, and they're the part a from-scratch writer always forgets.
End with the done-state. Finish by showing the result: "and now the report's in the shared folder and the channel's been pinged — that's the whole process." This gives the SOP a verifiable completion criterion, which is what separates a real runbook from a list of clicks.
Stop, and grab the link. When you stop, Clipy processes the recording (transcript, summary, key moments) and gives you a watch link. That link plus .md is the raw material. You're done recording forever — everything after this is the agent's job.

If you want a deeper walkthrough of the recorder itself, the Clipy screen recording guide covers the capture side in detail.

Hand the `.md` to an agent and prompt it to write the SOP

Now the conversion. You have a watch link; append .md to get the document. There are two ways to get it in front of an agent.

Zero setup — share the link. If the recording is public (or the agent's session is signed in for a private one), any agent that can fetch a URL — Claude, Cursor, ChatGPT with browsing — can read https://clipy.online/video/<id>.md directly. You paste the URL and the prompt, and it fetches the structured document itself. This is the fastest path and needs nothing installed.

Full access — the MCP server. If you want an agent that can reach across your whole recording library (write the SOP, then pull the three related recordings for the appendix), wire up Clipy's read-only MCP server. Run it with:

npx -y @clipy/mcp

Get an API key from clipy.online/settings/api-keys. The server is read-only and only ever sees your own recordings; the .md access rules still apply. It exposes a get_agent_context tool that returns the same structured context — summary, transcript, key moments — with frames inline, so the agent gets the pointer crops as images rather than links. Setup details are at clipy.online/docs/mcp, and the agent-facing overview lives at clipy.online/for-agents.

Either way, here's a prompt that reliably turns the .md into a clean SOP. Paste it, then paste the .md URL (or point the agent at the MCP context):

You are writing a standard operating procedure (SOP) from a screen
recording. I'll give you a Clipy .md document that contains a summary,
a timestamped transcript of my narration, and timestamped "key moments"
(some with click coordinates as fractions of the frame, a source of
fused/click/hover, a confidence value, and a cropped frame with a
marker on the click point).

Write the SOP as follows:

1. Title: a short imperative name for the process (from the summary).
2. Purpose: one or two sentences on what this accomplishes and who it's for.
3. Prerequisites: any tools, access, or starting state the narration implies.
4. Steps: numbered, imperative ("Click X", "Enter Y"). Use the control
   names I say in the transcript. For each step that has a matching key
   moment with click coordinates, note where on screen the control is
   (e.g. "top-right of the toolbar") based on the coordinate fractions.
   Prefer high-confidence click moments over hover moments.
5. Decision points and warnings: pull out every conditional or gotcha I
   mention ("if the file is over 10MB...", "make sure you're in production").
6. Completion criteria: how to verify the process is done, from my end state.

Rules: only use what's in the document. If a step is ambiguous in the
recording, flag it as [VERIFY] rather than guessing. Do not invent steps,
values, or UI that isn't in the transcript or key moments. Keep it tight
and repeatable — someone should be able to follow it without watching the
video.

The [VERIFY] rule matters: it's what keeps the agent honest. If your narration skipped a step or the coordinates were ambiguous, you want a flag, not a confident fabrication. Read the draft, fix the flags (often by re-recording that one part), and you have an SOP that's faithful to the process because it was built from the process.

A worked example: from four minutes of narration to numbered steps

Say you record the "export the weekly usage report" process on the Mac app. Four minutes, narrated. When you stop, the .md contains a summary ("Exporting the weekly usage report from the analytics dashboard and posting it to the finance channel"), a transcript with your spoken step-by-step, and a handful of key moments — each with a timestamp, a cropped frame of the control you clicked, and the click coordinates.

You paste the prompt above and the .md URL into your agent. It reads the summary for the title and purpose, walks the transcript for the imperative steps, and lines each step up with the nearest key moment to place the control on screen. What comes back is a numbered SOP: "1. Open the analytics dashboard. 2. Click Reports in the left sidebar. 3. Set the range to Last 30 days using the date picker in the top-right..." — with your "make sure it's the production workspace" aside pulled out as a warning and "the report appears in the shared folder" as the completion criterion.

You didn't retype any of it. You performed the process once and narrated it; the recording captured the clicks and your words; the agent assembled them into steps. This is the same pattern behind giving Claude, Cursor, or ChatGPT context from a screen recording and behind treating a recording as a readable document — the AI summary is what makes async video readable. An SOP is just the most structured thing you can build from that raw material.

Why this beats "record a process" SOP tools

There's a category of tools that watch you click through a process and auto-generate a step-by-step guide with screenshots. They're genuinely good at the mechanical "you clicked here, then here" capture. Where they fall short for real SOPs is the why: they capture the clicks but not the reasoning, the decisions, or the gotchas, because those live in your head, not in the click stream.

The recording-plus-narration approach captures both. The clicks come from the key moments; the reasoning, decisions, and warnings come from your narration in the transcript. And because the output is an agent writing prose from structured source material — not a template filling in screenshots — you can steer it: ask for a terse checklist for experts, or a hand-holding version for new hires, from the exact same recording. The recording is the source of truth; the SOP is a rendering of it, and you can render it more than one way.

The other advantage is that it's not locked in a proprietary format. The .md is plain Markdown you can read, diff, and version-control. Developers building on this can go further with the developer docs and the MCP server — the SOP-from-recording flow is one thing you can build on an agent-readable recording, not the only thing.

FAQ

Does Clipy have a "generate SOP" button?

No — and I won't pretend it does. There's no one-click SOP generator and no auto-published SOP page in Clipy today. The flow is: record the process, append .md to the link to get the structured document, and hand that to an AI agent with a prompt (there's a copy-paste one above) that writes the SOP. Clipy's job is to make the recording agent-readable; the agent writes the words.

How do I turn a screen recording into an SOP?

Record the process while narrating each step, stop to get the watch link, then append .md to that link. The .md gives you a summary, a timestamped transcript, and click-anchored key moments. Paste that document (or its URL) into an AI agent along with an SOP-writing prompt, and the agent produces numbered steps. You perform the process; the agent writes it up.

Can I make an SOP if I only used the web recorder?

Yes. The web recorder gives you a full summary and transcript — no click coordinates, but a well-narrated recording carries the process through your words. Name every control out loud ("click the Export button, then choose CSV") and the agent has what it needs. For the tightest steps with on-screen pointers, use the Mac app or the Chrome extension's recording, which do capture coordinates.

Which recordings include click coordinates?

The Mac desktop app and the Chrome extension's tab recordings capture click coordinates and pointer crops. The web recorder does not — it captures the summary and transcript only. For an SOP, coordinates let the agent point at exactly which control to click, so prefer the Mac app or extension when the process is desktop- or single-tab-based.

Can I keep the recording private and still hand it to my agent?

Yes. The .md follows the same access rules as the watch page — a private recording's .md needs a signed-in session. If you use the MCP server, it's authenticated with your API key and only ever reads your own recordings, so a private-by-default library still works end to end.

What does this cost?

Nothing. The recorder, transcripts, summaries, key moments, the .md, and the MCP server are all free — no watermark on recordings and no signup wall for viewers. You can start at clipy.online/screen-recorder and read the agent-readable side at clipy.online/for-agents.

Should I record multiple processes in one recording?

Record one process per recording. An SOP is one procedure; keeping recordings one-to-one with processes gives you a clean summary, a focused transcript, and a .md the agent can turn into a single tight SOP. If a process has genuinely separate sub-procedures, record them separately and let the agent stitch the appendix together — the MCP server can read across your library for exactly that.

The takeaway

The reason documenting a process is painful is that the standard order is backwards: you do the process fluently, then try to reconstruct it slowly from memory onto a blank page. Flip it. Perform the process once, narrating deliberately, and let the recording be the primary source. Append .md, hand it to an agent, and let the agent do the typing. You already did the hard part — the doing — and the recording captured it in a form an agent can read. That's the whole idea behind an agent-readable recording, and an SOP is the cleanest thing you can build from one.