TutorialsBreaking Down Workflows with AI
A six-step breakdown formula, 3 hands-on prompts and 5 templates — turn one fuzzy sentence into a runnable SOP in 15 minutes.
The workflow in your head is always fuzzy: "A customer reports a fault in the group chat, we send someone to look at it, they write up a plan, the customer confirms and we fix it." It sounds clear, but the moment you try to make it runnable you find holes everywhere — who triggers it and when, where each step's conclusion is stored, what happens when two people confirm at the same time. This lesson walks one complete path: use a six-step formula to break a one-sentence fuzzy workflow into a runnable SOP.
What you take away
| 1 six-step formula | 3 hands-on prompts | 5 templates | 1 SOP of your own workflow |
|---|---|---|---|
| Trigger → states → step table → data flow → boundary questions → automation levels | Break down / find gaps / assign roles | A full timeline from entry to review | A process document validated on a real case |
The three deliverables: live hands-on practice + template files (prompt pack) + homework.
Problems you may recognise
- You have run a process for three years and still cannot explain it clearly to someone else;
- You ask AI to "design a process for X" and it hands you industry best practice instead of your reality;
- The diagram looks fine, but the process breaks at step two — because nobody said where step one's conclusion lives;
- You find the gaps only after go-live: duplicate submissions, someone going silent, conflicting rules — all branches nobody thought of.
The problem is not that you cannot draw a flowchart. It is that the trigger, the states, the data flow, the decision branches and the automation boundary were never written down item by item — and all of it was already in your head.
What you will learn
The groundwork: four concepts and one formula
Four core concepts in plain language — state machine (what this object counts as right now), data flow (what is read, written and stored where), routing rules (which branch it should take), automation boundary (what AI can take over); a table of six common scenarios; then the heart of the lesson, unrolled step by step: trigger → states → step table → data flow → boundary questions → automation levels, each with its output.
Hands-on: three prompts that open the process up
Using a customer repair ticket as the main case, you run three prompts live — Prompt A for the first pass (state machine + step table + data flow), Prompt B for a QA review across six classes of boundary gaps, Prompt C to label every step fully automated / semi-automated / manual and rank what to automate first. Each prompt comes with its full text and the one thing to watch for.
Take-home practice: five templates and the red lines
Five copy-ready templates ordered by when you use them (capturing a new process / one sentence into a state machine / probing boundaries / automation assignment table / post-launch review); two blank tables you can use immediately (one-page workflow breakdown, state transition log); plus three general red lines and two specific to this lesson.
Who it is for
Course structure
This course has 3 lessons and 1 assignment: from understanding the four concepts and the six-step formula, to running a real process through three prompts, to moving it into your own role with the templates.
The groundwork: four concepts and one formula
State machine, data flow, routing rules and automation boundary explained in plain language, each with a concrete example; a look at how AI helps across six common scenarios; then a step-by-step unrolling of the six-step formula — what each step does and what it produces; plus the general prompt formula (role + task + context + format + constraints) and the single most valuable advanced tip.
Hands-on: three prompts that open the process up
Around the main case — a customer repair ticket process — starting from one spoken sentence: Prompt A yields the state machine, step table and data flow; Prompt B has AI act as a QA engineer and surface six classes of gaps (concurrent edits, abnormal interruption, timeout, missing values, state rollback, permission isolation); Prompt C labels each step with its automation level and ranks the changes.
Take-home practice: five templates and the red lines
Five copy-ready templates along the timeline of "capture a new process → structure it → complete the boundaries → assign automation → review after launch", each marked with when to use it; two blank tables you can fill in by hand; and finally the red lines, especially the two specific to this lesson.
The principle behind it all
In one sentence: AI produces the first draft and hunts for gaps; you judge and decide. The process in your head is always incomplete — the greatest value of AI is not "execution", it is "questioning".
Five red lines:
- AI makes things up with a straight face: numbers, dates and names must be checked by hand — it sounds just as confident when it is wrong;
- Never feed it confidential or sensitive information: anonymise first, or do not feed it at all — what you send out cannot be taken back;
- The output is not the final version: your name is on it, and so is the responsibility — review it once yourself before it goes out;
- Do not skip the raw description and let AI design the process: describe the current situation first, and let AI structure it;
- Always run the breakdown on a real case: a first pass misses at least 30% of the boundary cases.
Assignment: Write your own SOP card, then turn it into a workbench
Three levels merged into one assignment — run a scenario to get SOP v2, apply it to a repeated task in your own role, then build a first-version workbench. All three required.
The Groundwork: Four Concepts and One Formula
State machine, data flow, routing rules and automation boundary in plain language — then the heart of the lesson, the six-step breakdown formula, unrolled step by step.