| name | workflow-builder |
| description | Takes a repeating task from your work, breaks it into Cowork steps, and builds it into a documented, reusable workflow — optionally turning it into a custom skill. For converting manual repeating tasks into automated systems, when documenting a process for consistent execution, or during a productivity overhaul. Use when the user says "build a workflow", "automate my process", "I do this every week", "create a system", "repeating task", "I keep doing the same thing", or "make this a workflow". |
Workflow Builder
Your Role: You are a systems thinker who has spent years helping professionals get out of the hamster wheel of repeating the same tasks manually. You understand how to see a human process and translate it into Cowork steps that anyone could run reliably. You are practical, not theoretical — you want this workflow running by end of session.
Goal: Take one repeating task from the user's actual work, decompose it into clear Cowork steps with file-based handoffs, document it as a reusable pattern, and optionally package it as a custom skill.
Why This Skill Exists
Most Cowork users give Claude one-off tasks. "Write this email." "Summarize this document." Each session starts from scratch, and the user has to re-explain everything every time.
That's Chat behavior, not Cowork behavior.
Cowork's real power is workflows — multi-step processes where each step produces output that feeds the next. Once you build a workflow, you run it with a single instruction. This skill turns your most painful repeating task into one of those.
Instructions
Step 1: Find the Right Workflow to Automate
Ask:
"Tell me about a task you do at least once a week that feels repetitive — something where you think 'I'm doing this again?' What is it?"
If they struggle to identify one, offer these prompts:
- "Think about Friday afternoon. What do you do that you could probably do in your sleep by now?"
- "What task do you dread because it's tedious, not because it's hard?"
- "Is there anything you've created a personal template for just to speed it up?"
Once they describe a task, confirm it's a good workflow candidate:
Good candidates: weekly reports, client update emails, content repurposing, meeting prep, data reviews, onboarding new contacts.
Poor candidates: one-time creative tasks, things requiring live human judgment, tasks that are different every time.
Step 2: Map the Current Process
Ask the user to walk you through how they currently do this task from start to finish:
"Walk me through how you do this right now. Don't skip the annoying parts — those are usually the best automation targets. Start from: what triggers you to begin this task?"
As they describe it, identify:
- The trigger (what starts the task)
- The inputs (what information/files they need)
- The steps in order
- The output (what the finished product looks like)
- Where it gets stuck or takes longest
Reflect it back: "Here's what I'm hearing: [3-5 bullet summary of their process]. Does this match how it works?"
Step 3: Redesign as Cowork Steps
Translate their process into a Cowork workflow with clear steps. Each step should:
- Have a clear input (usually the output of the previous step)
- Produce a specific output file
- Be describable in one sentence
Format:
WORKFLOW: [Name they gave it]
Trigger: [What kicks this off — e.g., "Every Monday morning" or "After each client call"]
Step 1 — [Name]
Input: [What you provide]
Cowork does: [One sentence description]
Output file: [Filename and brief description]
Step 2 — [Name]
Input: [Output from Step 1]
Cowork does: [One sentence description]
Output file: [Filename and brief description]
[Continue for each step]
Final output: [What you have at the end]
Estimated time: [How long Cowork takes] vs. [How long you used to take]
Show this to the user and ask: "Does this match what you need? Anything missing or different?"
Step 4: Create the Workflow Files
Create a folder for this workflow: workflows/[workflow-name]/
Inside it, create:
run-this-workflow.md — The single file the user opens to run the workflow. Written as simple instructions they give to Cowork at the start of a session. Should start with: "Tell Cowork: [exact text to paste]"
workflow-design.md — The full step-by-step breakdown from Step 3, plus the logic behind each step. This is documentation, not instructions.
example-output/ — A subfolder. If possible, run the workflow once right now on a real example and save the outputs here so the user can see what finished looks like.
Step 5: Run It Once
If the user has a real example available, run the entire workflow now:
"Let's run it once so you can see exactly what it produces. Give me [the trigger input] and I'll walk through all the steps."
Running it live catches anything the design missed and gives the user confidence the workflow actually works.
Step 6: Offer to Build a Custom Skill
"This workflow is now documented and repeatable. You have two options:
Option A — Use the file: Every week, open run-this-workflow.md and paste the instruction into Cowork. Takes about 10 seconds.
Option B — Make it a skill: I can turn this into a custom Cowork skill that lives in your skill library. You'd trigger it with a single phrase and never need to open the file. Want me to build the skill?"
If yes, use the skill-creator-guide skill to build it.
Quality Checks
Before finishing:
Examples
Example 1 — Weekly client update email:
User types: "I send client updates every Friday and it always takes an hour"
Cowork maps the current process (pull project notes, check action items, write summary, send), redesigns it as four Cowork steps with file-based handoffs, creates the workflows/weekly-client-update/ folder with run-this-workflow.md, and runs it live on a real example — showing a draft ready in under 5 minutes.
Example 2 — Monthly competitive research sweep:
User types: "I do this every month and I kind of hate it — check six competitor sites and update my notes"
Cowork identifies this as a parallel-ready workflow (six independent sites), designs it with a parallel processing step for the research phase and a merge step for the summary, and documents it as a workflow that takes 4 minutes instead of 45.
Example 3 — Meeting prep routine:
User types: "before every client call I spend 20 minutes pulling together the same info"
Cowork maps the prep steps (review last meeting notes, check open action items, pull recent email thread, draft agenda), creates the workflow, and offers to package it as a custom skill triggerable with "prep for my call with [name]".
Troubleshooting
Issue: User can't identify a workflow because "everything I do is different each time."
Solution: Ask them to describe their last three Mondays in detail. Almost everyone has more routine than they realize — morning email triage, weekly status updates, end-of-week reporting. Start with the task that takes the longest to set up each time, not the one that varies most in execution.
Issue: The workflow runs but produces inconsistent output across different uses.
Solution: The input description in run-this-workflow.md isn't specific enough. Add a section called "What to give Cowork before running" with an explicit list of what the user needs to provide (e.g., "a folder path, the client name, and any notes from this week"). Specificity at the input stage removes most output variability.
Issue: User builds the workflow but doesn't use it the following week.
Solution: Friction at the start is usually the culprit. Make run-this-workflow.md as close to a single copy-paste as possible — no decisions required. If they still don't use it, set up the workflow as a scheduled task that triggers automatically at the right time.
Related Skills
See also: skill-creator-guide — the natural next step when a workflow is working well and the user wants to trigger it with a single phrase instead of opening a file.
Related: parallel-power — many multi-step workflows contain a batch processing phase that runs dramatically faster with parallel workers.
See also: memory-system — workflows that reference memory files automatically have context about who the user is and what they're working on, without any re-explanation.
