AI SOP generator: a prompt, a template, and the check that makes it true

Ask ChatGPT to "write an SOP for processing supplier invoices" and you'll have one in seconds. Purpose, scope, eight tidy steps, a section on exceptions. It will also describe nobody's actual process. It's the average of every invoice SOP the model has read.

An SOP is only useful if it matches what people do, including the workaround with the shared inbox and the step that only happens at month end. Process-mining vendors make the same point from the data side: Celonis sells software to show "how your processes actually run – not how you think they do" (Celonis). A model working from a description gets the second half.

So the question isn't which generator. It's what you feed it. SOP generators come in three kinds, and they differ mainly in their inputs:

For most ops teams we'd draft in Claude from real evidence, set up once as below, use a capture tool for the purely on-screen parts, and treat both as drafts until someone who does the job has walked them.

Paste it into Claude as it is, or make it a skill (next section) so nobody has to. It works in ChatGPT too. It asks for the source of every step, which makes the final check quick. The XML tags follow Anthropic's advice to keep material and instructions apart (Anthropic, Prompting best practices).

<sources>
<transcript>[a call where someone does the task and talks it through]</transcript>
<screenshots>[attach screenshots of each screen, numbered in order]</screenshots>
<existing_doc>[the current SOP or wiki page, with its last-updated date]</existing_doc>
<interviews>[notes from people who do the job, one block per person]</interviews>
</sources>

Write a standard operating procedure for [task], as done by [team] at [company].

Rules:
- Use only the sources above. Do not add steps from general knowledge of how this kind of process usually works.
- Tag every step: [observed] if the person does it on the call or it is visible in a screenshot; [described] if someone says it happens but it isn't shown; [assumed] if you added it to make the procedure complete. Cite the source: transcript timestamp, screenshot number or interviewee.
- Where sources disagree, do not choose. List the conflict under "Open questions".
- Where a step needs judgement, say what the person decides and what they look at to decide it.
- If the sources don't cover something the procedure needs (an exception, an approval), list it under "Open questions". Don't invent it.

Use this template:

And the template it fills:

SOP: [task name]
Owner: [who maintains this] | Version: [n] | Last walked: [date, by whom]

Purpose: [one sentence: what this produces, and for whom]
Trigger: [what starts the process]
Done when: [the observable end state]
Systems and access: [tools and permissions needed]

Steps
1. [action] | [tag] | [source]
   You should see: [what tells you it worked]
2. ...

Decisions and exceptions
- If [condition], then [action]. | [tag] | [source]

Handoffs
- From [whom] to [whom], via [channel], within [time]

Open questions
- [conflicts between sources, gaps, assumed steps awaiting confirmation]

Change log
- [date] | [what changed] | [who walked it]

Two rules carry the weight. The tags turn a review from "does this look right?" into a list of specific steps to confirm. The conflict rule stops the model quietly picking the tidier version, which is usually the out-of-date document.

Pasting a prompt works once. For a team that writes SOPs every week, set Claude up so the rules apply without anyone remembering them. An hour is enough.

1. Create a project called something like "SOPs: [team]" (Anthropic: what are projects?). Projects are on every plan; Free is capped at five. Upload your SOP index and the glossary of system names, and paste these instructions:

This project writes and updates SOPs for [team].
Always use the sop-writer skill. Never add steps from general knowledge.
Our systems: [list, with the names people use for them].
Approvals: [who signs off what], so you can flag missing ones.

1. Turn the prompt into a skill. Make a folder named sop-writer holding a skill.md (the rules from the prompt above, under a short name and description) and a template.md (the template). Zip it with the folder at the root, upload it, and switch it on under Customize > Skills. Skills need code execution enabled (Anthropic: how to create custom skills). Claude loads the skill only when an SOP is asked for, so it doesn't crowd other chats.

---
name: sop-writer
description: Writes or updates an SOP from transcripts, screenshots and existing docs, tagging every step observed, described or assumed, with its source.
---
[paste the Rules list from the prompt above]
Fill template.md. Set "Last walked" to "not yet".

1. Connect the sources through Customize > Connectors (Anthropic: custom connectors); Free accounts get one custom connector. The Granola MCP server fetches meetings and, on paid plans, transcripts. The Atlassian Rovo MCP server searches and reads Confluence. Notion MCP does the same for Notion, and includes tools that delete pages, so keep approval on.

2. Run it: "Use the sop-writer skill on yesterday's [meeting] and the Confluence page [title]."

3. Publish by hand. Both Atlassian's and Notion's servers can create pages. Leave that to a person, after the walk, so the published version is the checked one.

If your company runs ChatGPT, put the template in a ChatGPT project's files and the rules in its instructions; the prompt works unchanged.

The draft can't be truer than what goes in. In order of how far we'd trust them:

1. A recording of someone doing the job. A screen-share where an experienced person does the task and narrates is the best single input: you get the clicks and the reasons. With Granola connected (step 3 above), Claude pulls the meeting directly; transcripts need a paid plan, and the free plan reaches only the last 30 days (Granola docs). Transcription can add its own errors. In one study, about 1% of Whisper transcriptions contained whole invented phrases or sentences (Koenecke et al., 2024). Confirm any step that rests on a single line of transcript.

2. Screenshots. Claude accepts images up to 8000×8000 pixels and up to 20 files per chat (Anthropic Help Centre). Number them. For on-screen steps they're the strongest evidence, because they can't be misheard.

3. Interviews with the people who do the work. Ten minutes each with two people, asking "what do you do when it goes wrong?", catches the exceptions recordings miss. Two matters. Where they differ, you've found a step that isn't standard yet.

4. The existing doc. Useful for structure and for what the process was meant to be; least trustworthy for what happens now. If it lives in Confluence or Notion, Claude fetches it through their MCP servers. Give it the last-updated date as well.

What not to feed it on its own: a manager's description of the process. That's the "should" version, and the model will write it up beautifully.

Dedicated tools exist, and for some SOPs they're the better choice. We opened the official pages of three in October 2026 and describe only what those pages say.

None of the three homepages showed prices. Scribe and Tango both offer a free start; we couldn't confirm what their free plans include. Of the three, only Scribe's homepage mentions MCP, so it's the one whose captures could feed a Claude draft directly.

Capture tools have one strength a chat assistant lacks: what they record was observed. Every step happened on someone's screen. Their weakness is the mirror image. They record one run, by one person, with that person's habits and shortcuts, and nothing that happened away from the screen. A capture of the happy path is a very accurate record of the happy path.

An SOP review where a manager reads the draft and says "looks right" checks almost nothing. Reading is the wrong test for a procedure. Doing it is the right one.

Sit with someone who does the job (ideally not the person you recorded) and have them do the task from the SOP. Mark each step:

The AI's own tags are where you start, not the result. A step tagged [observed] from a transcript can still fail the walk, because the person on the call skipped something they always do.

A two-minute check before the walk

1. Count the [assumed] tags. More than one or two in a ten-step SOP means the inputs were thin. Get another recording.
2. Open three citations. Find the timestamp or screenshot for three steps. Is it there, and does it say that?
3. Read the open questions. If there are none, be suspicious: real processes have conflicts.
4. Ask: "Which steps did you include because SOPs like this usually have them?" Confirm or delete each one.
5. Check exceptions against the interviews. Every "what if it goes wrong" answer should appear somewhere.

Anthropic's advice for grounded output is the same idea: find a supporting quote for each claim, and "if you can't find a supporting quote for a claim, remove that claim" (Anthropic, Reduce hallucinations). An SOP step is a claim about what people do.

If the SOP came out of a long conversation with Claude or ChatGPT, Count can do the sorting for you. Ask it to audit the answer and each claim comes back labelled Citation, Assumption, Model knowledge or Hallucination, with the reasoning chain behind it.

Processes drift. A tool moves a menu, a team adds an approval, someone finds a faster way and tells nobody. Two habits keep an AI-drafted SOP honest.

Date the walk, not the edit. "Last walked 3 March by Priya" (an illustrative example) tells a reader how far to trust it. "Last edited" only says someone touched the file.

Store it where the assistant will use it. If Claude helps run the procedure (the weekly close checklist, onboarding a supplier), save the walked SOP as its own Claude skill, built the same way as the sop-writer. A skill makes Claude follow the procedure faithfully, mistakes included, so update it after the walk and not before.

When you re-walk, regenerate from the new recording and compare versions. The difference is the process change, written down for the first time. More in AI for operations and, for finding where a process is slow, AI for process improvement.

Can Claude write SOPs?

Can ChatGPT write an SOP?

What is the best AI SOP generator?

Is there a free AI SOP generator?

How do I check an AI-written SOP is accurate?