Staffing Agency Workflow: Cut Match Notes and Job Pitches From 30 Minutes to 5 With Claude Code

Friday, 5 PM. You just wrapped an interview with a candidate, and all you’ve got in your head is a hunch: “This person would probably fit that warehouse role.” But the pitch is still a blank page. Monday morning you have to send five separate candidates their job recommendations, first thing.

When I sat next to a friend who works as a staffing coordinator and watched her work, this was the part that ate the most time. Interview notes were scattered across a notepad. Job pitches got built by copy-pasting an old message and swapping out the name, the hourly rate, and the location. Read them back, and sometimes you’d find a phrase aimed at the previous candidate still sitting in the text.

And the pitches she rushed were always the thinnest ones. “Near the station, great pay, no experience needed” — generic lines you could slap onto any role. Reply rates didn’t move.

In this article, I’ll show you how to hand that “match note and job pitch” work to Claude Code and let AI draft it, so the human can focus on the finishing touches. There’s barely any code talk. Instead, you get copy-paste prompts, a checklist that structures your interview notes, and a verification script that filters the output before it goes out.

Key takeaways

• The goal: help a staffing coordinator drop the time to build a match note and a job pitch from around 30 minutes per candidate to around 5.
• What you hand to AI stops at “mass-drafting” and “tidying up phrasing.” The fit between candidate and role, and the final check on rates and conditions, stay with the human.
• I’ve prepared two ready-to-paste prompt templates: one for match notes, one for job pitches.
• There’s a 20-line verification script that mechanically checks whether a personal name or stray hourly rate slipped into the output.
• Personal data gets its own section. Names, phone numbers, and home addresses get masked before anything reaches the AI.

Where staffing coordinators actually lose their time

Let’s pin down who this is for. This article assumes a coordinator at a temp-staffing or temp-to-perm agency who runs the whole loop solo: candidate interviews, role proposals, and the back-and-forth with the client company. You interview three to six people a day, and in the gaps you send out 5 to 15 job pitches. Many of you also carry a sales quota.

Sketch out the workflow and it looks roughly like this:

1. Interview the candidate; gather their wishes, work history, and personality.
2. Write the intake into a match note and store it in your internal system or a spreadsheet.
3. Pick two or three roles from your inventory that fit well.
4. Write a job pitch for the candidate and send it by email or chat.
5. Watch the response, then send the client a recommendation or candidate write-up.

Steps 2 and 4 are the writing work. The interview itself, and the eye for whether two people will click, only a human can do. But the “transcribe and tidy up” part of the notes and the pitch is almost the same procedure every time. That’s where generative AI earns its keep.

The common rework and headaches

Watching from the side, the patterns where rework crept in were almost always the same four:

• Copy-paste accidents: Reuse an old pitch, and the previous candidate’s name or another role’s hourly rate gets left behind. You notice after you hit send, then write an apology email.
• Thin pitches: Write in a hurry and you end up with “friendly workplace” and “no experience needed,” missing the one line that actually speaks to this person’s background. No reply comes.
• Inconsistent note detail: On a busy day the note is three bullet points; on a calm day it’s ten lines. Look back later and you don’t have enough to decide on.
• Doing it twice: You write the candidate-facing pitch and the client-facing recommendation from scratch, twice — even though the source material is the same.

Before the change, at least one of these four happened somewhere every week. Once drafting moved to AI, note detail leveled out and every pitch reliably carried “the one line just for this person.” The copy-paste accidents get caught by the verification script I’ll show you later.

Use case 1: Structure interview notes into a match memo

The raw note right after an interview usually isn’t even sentences. It’s a scrawl: “3 yrs call center, wants weekends off, commute under 30 min, leans service over manufacturing, no career gap.” The first job is to shape that into something you can search and compare later.

What you hand off stops at “shaping.” The human weights the decision factors. Convert it into the checklist fields below and the note detail comes out consistent every time.

• Preferred roles / roles to avoid
• Location and acceptable commute time
• Target hourly rate / minimum floor
• Work days / shift conditions
• Work history summary (most recent role and years)
• The “non-negotiables” the candidate stated in their own words
• Coordinator’s note (personality, likelihood of staying)

That last field is the only one you don’t let the AI write — the human adds a line. That’s where a staffing agency’s value lives.

Use case 2: Mass-draft the job pitches

Once the match note and the role details are lined up, the pitch draft can go to the AI. The key is to make it write one sentence — “why I’m recommending this role to you” — that ties the candidate’s background to the role’s features. Just that one line kills the template feeling.

The table below draws the line between what you hand to the AI and what the human always checks.

Step	Hand to AI	Human always decides
Note shaping	Structuring into bullets	Read on personality / retention
Role selection	Narrowing the shortlist	Final go / no-go on the intro
Pitch draft	Generating and tidying prose	Verifying rate / location numbers
Tone tuning	Adjusting politeness / length	Decision to send to the candidate
Client recommendation	Drafting by repurposing the pitch	Fact-check before it reaches the client

There’s a reason number-checking stays with the human. Generative AI will sometimes write a plausible-looking hourly rate or date out of thin air. Any number not in the source data, you treat with suspicion.

Use case 3: Repurpose the candidate pitch into a client recommendation

For the same person, the candidate sees “why this fits you,” and the client sees “why you should hire them.” The angles are reversed, but the source is the same match note. Once the candidate-facing draft exists, have the AI rewrite it for the client and the double work disappears.

When you repurpose, spell out in the prompt that information only the candidate should see — their minimum rate floor, the raw reasons they’re job-hunting — gets dropped from the client version. Forgetting to drop it becomes an incident, so the verification script catches that too.

If you’ve never touched Claude Code, skim Getting started with Claude Code and Claude Code for non-engineers first, and the prompts below will land much more easily.

Copy-paste prompt templates

First, the match-note prompt. Paste the raw note straight from the interview. Replace names and phone numbers with placeholders before you paste (reasons below).

You are an assistant to a staffing-agency coordinator.
Reshape the interview note below into a match memo that can be searched and compared later.

# Rules
- Fill every field below. For any field with no information, write "unconfirmed."
- Do not invent an hourly rate, location, or date that isn't in the note.
- Leave the read on personality / retention blank for the human to add.

# Output fields
- Preferred roles / roles to avoid
- Location / acceptable commute time
- Target hourly rate / minimum floor
- Work days / shift conditions
- Work history summary (most recent role and years)
- Non-negotiables
- Coordinator's note (leave blank)

# Interview note
<<paste the raw note here>>

Next, the job-pitch prompt. You hand it the shaped match memo plus the role details.

You are an assistant to a staffing-agency coordinator.
Write a candidate-facing job pitch as a polite 150-200 word draft.

# Required elements
- Open with one sentence on why you're recommending this role to this candidate, tying their background to the role's features.
- List the work, location, hourly rate, and shift as bullet points.
- Keep numbers (rate, days, duration) exactly as in the role details; do not invent them.
- Close with one sentence prompting the next step (a question or scheduling an interview).

# Match memo
<<paste the shaped memo>>

# Role details
<<paste the role conditions>>

Just switching between these two stabilizes both note detail and pitch structure. If you want to go deeper on sharpening prompts, read Advanced prompt engineering alongside this.

The verification script that filters the output

Once you can mass-draft, the next worry is “did the previous candidate’s name get left behind?” A machine is better at this than the human eye. Here’s a roughly 20-line Node.js script that checks whether a generated pitch contains any forbidden words (a past candidate’s name, another role’s location, and so on). You don’t need @anthropic-ai/sdk or anything — it runs on plain Node.js.

// check-draft.mjs
// Usage: node check-draft.mjs draft.txt
import { readFile } from "node:fs/promises";

// Words that must NOT appear in the output (past candidate names, other roles' locations, etc.)
const forbidden = ["Mr. Tanaka", "previous role", "Yokohama branch", "$18/hr"];

const file = process.argv[2] ?? "draft.txt";
const text = await readFile(file, "utf8");

const hits = forbidden.filter((word) => text.includes(word));

if (hits.length === 0) {
  console.log("OK: no forbidden words found.");
} else {
  console.log("Needs review: these words are still in the pitch ->", hits.join(", "));
  process.exitCode = 1; // use this when you want automation to halt
}

You just rewrite the forbidden array to fit the roles you handle. Run this once before sending and the copy-paste accidents from the intro nearly vanish. For how to bake this verification into your CLAUDE.md, CLAUDE.md best practices covers it in detail.

Personal data and security notes

This is the most important part for a coordinator. Candidate names, phone numbers, home addresses, and previous employers’ company names do not get handed to generative AI as-is. The reason is simple: sending personally identifiable information to an external AI service can, by itself, break the promise you made to your registered candidates.

Concretely, here’s what you do before anything reaches the AI:

• Replace names with “Candidate A” or “Candidate X.”
• Delete phone, email, and address fields entirely.
• Reduce a previous employer to its industry only, e.g. “a large call center.”

When the draft comes back, swapping the placeholders for real names happens in your own local text editor by hand. If your company doesn’t yet have a rule for using generative AI, decide the scope of use first. In the US, the FTC’s guidance on protecting consumer data and privacy is worth reading once to give your internal rules a foundation.

ROI, before and after

The numbers are a rough guide only. On my friend’s team, we measured the build time per pitch.

• Before: reusing and hand-fixing an old message, roughly 20-30 minutes per pitch.
• After: drafting plus finishing, roughly 5-8 minutes per pitch.

Suppose one coordinator runs 10 pitches a day. A 20-minute saving per pitch frees up about 200 minutes a day — over three hours. At 20 working days a month, that’s 60-plus hours. You can pour that time into more interviews, or into follow-up contact with candidates.

Of course, the first few days actually take longer — you’re tuning prompts and building out the forbidden-word list. The payback started showing up around the second week. For the small daily time-savers, productivity tips collects more of them.

If you want to rework the writing side of your staffing operation company-wide, starting from training and consulting — where we build the prompt design and operating rules together — tends to make it stick on the floor.

FAQ

Q. If I hand it to AI, won’t the pitch read mechanically? A. It will — but only when you haven’t made “the sentence tying background to role” mandatory. Force one sentence on why you’re recommending the role into the prompt and the template feeling mostly disappears. The final polish is still done by a human.

Q. Do I need to wire AI directly into our internal system? A. No. To start, just paste the note and role details in and take the draft back out. That alone carries the load fine. System integration can wait until the workflow is settled.

Q. Won’t the AI get the hourly rate or location wrong? A. It will. That’s exactly why number-checking stays in the human’s step. Generative AI sometimes writes a plausible number that isn’t in the source data, so always reconcile against the role details before sending.

Q. If I mask the candidate’s name, won’t the text read unnaturally? A. At the draft stage, “Candidate A” is fine. You just replace “Candidate A” in the returned text with the real name in your own editor — a single find-and-replace does it.

What I found when I actually tried it

I took five interview notes from my friend and ran them through the prompts and the verification script above. I wanted to confirm three things: the time per draft, the detection of copy-paste accidents, and how much hassle the masking adds.

The pitch drafts took roughly five minutes each to take shape. The biggest lever was the “one sentence on why I’m recommending it” instruction — just having it turns the text into something a candidate actually wants to reply to. I fed the verification script a draft where I’d deliberately left an old candidate’s name in, and it correctly halted with “Needs review.” The masking felt like a chore at first, but since it’s a single find-and-replace, I got used to it in two days.

On the flip side, there was one moment where the AI quietly rounded a role’s number — the last two digits of the hourly rate had changed. Keeping the final number check with the human was the right call. Drafts from AI, judgment and numbers from the human. As long as you hold that line, building match notes and job pitches gets reliably lighter.