4. Mapping a Process

🎥 Video lesson — video not yet migrated (source Skool video id: b42a55ea56994e9381dd4ea92903dce5).

In the last lesson you built the skeleton of a content plugin. Before we add real capability files, there's one step most people skip — and it's the reason most AI automations produce inconsistent output.

This lesson covers process mapping: how to break any workflow down into steps before you write a single instruction. You'll see why thinking in terms of systems (input → process → output) is the core skill behind building AI agents, and you'll get the exact prompt to map your own workflows in under 15 minutes.

🎯 What you'll do in this lesson → Understand why jumping straight to building without mapping first produces vague, inconsistent agents → Walk through the content ideation workflow as a real input/process/output example → Use the Workflow SOP Builder prompt to map your own process in Claude → Learn the difference between auto mode and human-in-the-loop mode — and when to use each

📐 The core skill: thinking in systems Every step of every process has three parts: an input (what you need before you can start), a process (what you do with it), and an output (what you produce). Once you can describe a workflow that way, writing agent instructions becomes mechanical — you're just translating each step.

✅ What you'll leave with A process map for your own workflow and the SOP Builder prompt saved to a Claude Project, ready to use any time you need to map a new automation.

→ Next up: CW-5 — Building the Plugin. You'll take this map and start turning it into real files.

Process mapping before building

In CW-3 you built the skeleton of a content plugin — one agent, one basic skill. The folder structure is there. Now we need to fill it in.

Before we do, there's one step that separates plugins that work consistently from plugins that kind of work sometimes.

The step most people skip

Most people sit down to write a capability file and immediately hit a wall. They want to automate content ideation, so they open the file and type: "Help the user generate content ideas."

Then they pause. What does the agent need to know first? What should it produce? What does done look like?

The real problem isn't the instructions — it's that the workflow was never actually articulated. You would be surprised how often people want to automate something they can't fully explain. And if you can't explain it clearly to another person, you can't explain it clearly to an AI agent.

The fix takes 15 minutes: map the workflow before you write a single instruction.

Thinking in systems

The core skill behind building AI automations is being able to think of every step of a process as three things:

  • Input — what information do you need before this step can run?
  • Process — what do you actually do with that information?
  • Output — what do you produce at the end of this step?

Here's the content ideation workflow broken down that way:

Step 1: Load Context

  • Input: Brand voice, ICP (ideal customer profile), and any other relevant files
  • Process: Ingest and confirm the context
  • Output: Confirmed context summary — ready for the next step

Step 2: Generate and Score Content Concepts

  • Input: Confirmed context from Step 1
  • Process: Generate 3–5 content concepts, then score each one against your ICP criteria — relevance, uniqueness, brand fit, platform potential
  • Output: Ranked scorecard with per-concept rationale

Gate: this is where a human reviews the concepts and picks the one to carry forward.

Step 3: Compile Brief

  • Input: Selected concept + all outputs from Steps 1–2
  • Process: Assemble everything into a structured brief document
  • Output: A complete concept brief, ready to hand off to copywriter or video editor agents

Once you have a workflow mapped this way, writing capability files is straightforward — each step becomes a file, and the instructions almost write themselves.

Auto mode vs human-in-the-loop mode

Notice the gate between Step 2 and Step 3. That's a human checkpoint — the agent pauses and waits for you to review and approve before continuing.

You have two choices for how to handle checkpoints:

Human-in-the-loop mode — the agent checks in with you after each step. You review the output, approve it, and tell it to continue. This is how you should start. It lets you catch problems early and refine your capability files until the output is consistently good.

Auto mode — the agent runs through all steps without pausing. Once a step is producing perfect output every time, you can update the capability file to skip the checkpoint and proceed automatically.

Start with human-in-the-loop. Switch to auto only when a step has been validated.

Map your own workflow — the SOP Builder prompt

Open claude.ai/projects, create a new project, and name it SOP Builder. Paste the following as your project instructions:

You are a business process analyst helping me map a workflow so I can build an AI plugin for it.

Interview me one question at a time. Wait for my answer before moving on.

Start with: "What workflow do you want to map? Give me the name and one sentence on what it does."

Then work through these areas in order:

1. TRIGGER — What starts this workflow?
2. STEPS — Walk me through each step from trigger to done. For each step I describe, ask:
   - What inputs does this step need before it can run?
   - What does it produce?
   - Is there a human checkpoint here — and what does the human decide?
3. DECISIONS — Are there any branching paths? If X happens, does the process go a different direction?
4. OUTPUT — What does the final result look like? What format? Who or what receives it?
5. HANDOFFS — Does this workflow feed into another workflow? What information gets passed along?

After the interview, produce this deliverable:

---

## Process Map

### Step [N]: [Name]
- Trigger: [what initiates this step]
- Inputs: [what information is needed before this step runs]
- Process: [the 2-4 actions that happen in this step]
- Output: [what this step produces]
- Checkpoint: [yes/no — and if yes, what does the human decide]

---

## Plugin Blueprint

- Agent identity: [one sentence — role + scope + voice]
- Capabilities to build (one file each): [list each step as a named capability file]
- Reference files identified: [any inputs that are reusable context, not task-specific data]
- Build order: [which capability to start with and why]
- Downstream handoffs: [where the final output goes]

---

Keep the interview conversational. One question at a time.

Then start a conversation and let Claude interview you about your actual process. Answer honestly — not what you think a perfect process looks like. The messier and more specific your answers, the better the blueprint.

If you're not sure which workflow to map, start with a work week audit. Think about how you (or your team) actually spend time: maybe 5 hours a week following up leads, 15 hours on content creation, 10 hours on quoting and proposals. The goal is to group your hours into process categories first, then drill into the granular steps for each one. Every group is a potential plugin.

If you completed WIRE 2.3–2.5, your process maps already exist. Each department = plugin. Each process = skill. Each step = capability file. Skip the interview and use your existing maps.

What's next

Once you have a process map, you have everything you need to build.

Each step in your map becomes a capability file. Each reusable input (brand voice, ICP, scoring criteria) becomes a reference file. The build order is just the sequence of steps.

In CW-5 we take the content ideation map and start building those files — starting with load-context.md.

→ Next: CW-5 — Building the Plugin

← Previous
Next →