QUICK ANSWER
Record your screen while doing the process and explain the steps as you go. Give the Clipy link to your agent and ask it to write the SOP. You demonstrate the work naturally; the agent helps turn it into a procedure that you can check and share with the next person.
Write an SOP from the process I demonstrate in this Clipy recording: [link].
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 recording context.
What the recording context actually contains (the raw material for an SOP)
Give the agent the normal Clipy recording link:
Read this Clipy recording and help me with the task: [paste the normal recording link].
There is no conversion step and no "export" button: the recording context is generated for every recording and served live. It obeys the same access rules as the watch page: a public recording's recording context 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 recording context 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: which recordings have them
Click coordinates and the pointer crops come from the desktop apps (Mac and Windows) and the Chrome extension's tab recordings, so record SOPs with those. The Mac app also records the label of the control you clicked when the app exposes one.
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 a desktop app or the extension's recording. If you're capturing a multi-window desktop flow or something outside a single browser tab, the Mac or Windows app is the one that gives you coordinates.
Narration matters on every recording: saying "now I'm clicking the blue Export button in the top-right" gives the agent the control names it needs for each step.
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 or Windows app (you get click coordinates). A single browser-tab workflow → the Chrome extension's recording (also coordinates). 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.
- 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, and 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 recording context is the raw material. You're done recording. 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.
How do you ask the agent to write the SOP?
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.
Use this Clipy recording to draft an SOP. Give me the prerequisites, numbered steps, and checks that show each step worked. Flag anything the recording leaves unclear: [recording link].
Review the draft before your team relies on it. The agent should describe the process shown in the recording, not invent missing steps.
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 recording context 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 recording context 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 recording context 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?
Yes. On the recording's watch page, open the Generate tab and choose SOP, or How-to guide for a step-by-step walkthrough with screenshots. Clipy drafts it from the transcript and key moments, you can edit the text, and you can share it as a guide next to the recording. If you want a format of your own, give your agent the normal link and ask for it, as described above. Either way, review the draft before your team relies on it. To try it on a recording first, use the screen recording to SOP tool.
How do I turn a screen recording into an SOP?
Narrate the process while recording it, then give your agent the normal Clipy link. Ask it to use the skill to draft an SOP, identify any unclear steps, and wait for your review before treating the draft as the final procedure.
Can I make an SOP if I only used the web recorder?
Yes. The web recorder gives you a full summary and transcript, and 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 steps anchored to on-screen pointers, use the Mac app, the Windows app or the Chrome extension's recording, which capture coordinates.
Which recordings include click coordinates?
The Mac and Windows desktop apps and the Chrome extension's tab recordings capture click coordinates and pointer crops, and the Mac app adds the clicked control's label. For an SOP, coordinates let the agent point at exactly which control to click, so prefer a desktop app or the extension when the process is desktop- or single-tab-based.
Can I keep the recording private and still hand it to my agent?
Yes. Private recordings require the right access. Ask the agent to connect your Clipy account and follow the sign-in prompt if needed. Installing the skill does not make a private recording public.
What does this cost?
Nothing. The recorder, transcripts, summaries, key moments, SOP generation, the recording context, and the MCP server are all free, no signup required 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 recording context 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
Demonstrate the process once and share the normal Clipy link with your agent. Ask it to write the procedure from the recording, then check the draft against what you actually did.