How RPO Recruiters Can Speed Up Candidate Emails and Pipeline Tracking with Claude Code

Friday at 5pm. Three clients, thirty-five candidates between them. Interview-scheduling replies, rejection notes, document reminders. I sat there with my inbox open, spending thirty minutes just deciding what to touch first.

And then I did it. I sent a candidate at Company B an email I’d written for Company A — “Your next interview is Tuesday.” The second I hit send, the blood drained out of my face.

Recruitment process outsourcing (RPO) is a job where this kind of mental gear-shifting goes on all day long. Every client has a different hiring flow and a different tone of voice. Every candidate is at a different stage. As long as you’re running all of that on memory and willpower, something will break during your busy season. It’s only a matter of when.

What I did over the last few months wasn’t “fully automating” my email. It was drawing one clear line: let Claude Code handle drafting and organizing, but keep the decision to hit send in human hands. Today I’ll walk through exactly how, with copy-paste prompts and a check script you can run.

Key takeaways

• Most RPO rework doesn’t come from “writing the email” — it comes from losing track of which candidate is at which stage.
• Hand Claude Code the candidate email drafts, the pipeline-status review, and the “who’s stalled” detection. Keep sending and hire/no-hire decisions with the human.
• Once you templatize the drafts, an email that took 5–8 minutes drops to 1–2. At 100 emails a week, that’s roughly 20 hours a month back.
• Don’t feed real names or contact details to the AI. Run everything on pseudonymous IDs and stage labels.
• This post includes a ready-to-use prompt template and a script that surfaces stalled candidates in your pipeline.

Who this is for, and where RPO recruiters always get stuck

This article is written for the RPO specialist who’s absorbing the hiring work of several client companies at once. You’re handling 5–10 companies on your own, with dozens of candidates running in parallel at any time. Sourcing replies, agency back-and-forth, interview scheduling, offer and rejection notes — almost every channel funnels through you.

Let me lay out the usual workflow first:

1. Interview each client to nail down the ideal candidate profile and the hiring flow.
2. Source candidates through job boards and agencies.
3. Send candidates the result of the document/resume screen.
4. Schedule the first and second interview rounds.
5. After each interview, get the client’s evaluation.
6. Send the offer or the rejection.
7. Share a progress report with the client.

This flow itself doesn’t change much from one RPO to the next. The problem is that you’re running the same flow across many companies at the same time.

Here’s the rework that always shows up. Sound familiar?

• You reuse a message written in Company A’s tone for Company B, and it lands wrong.
• The “reply within 48 hours of the interview” promise quietly breaks once candidate counts climb.
• A candidate stuck waiting on a client’s evaluation gets forgotten for a few days.
• You write every rejection note from scratch and burn yourself out by evening.
• The status in your spreadsheet drifts away from what’s actually been sent.

None of this is a competence problem. It’s that the volume of parallel work outpaces how fast a human can switch context. That’s exactly where AI earns its place.

What to delegate to AI, and what a human must always decide

Let’s draw the line clearly up front. Leave this fuzzy and you get accidents like my misfire above.

Task	Delegate to Claude Code	Human always decides
Candidate emails	Drafting and tone adjustment	Hitting the send button
Pipeline status	Reviewing the list, flagging gaps	The actual hire/no-hire call
Scheduling	Wording candidate dates, reminder drafts	The final confirmation message
Progress reports	Tallying numbers, building a draft	Whether to share it with the client
Rejection notes	Generating a considerate message	Whether the rejection reason holds up

The principle is simple. If a mistake stops in your drafts folder, let AI handle it. If a mistake leaves the building and can’t be taken back, the human holds it. Sending, the hire decision, the confirmation message. Decide that those three are the last things a human finger touches, and you won’t have accidents even at peak season.

If you want a fuller framework for deciding these boundaries, the piece I wrote for non-technical readers, how non-engineers should think about Claude Code, is a good companion.

Use case 1: Mass-produce candidate email drafts from patterns

This is where the biggest payoff lives. Look closely at RPO email and you’ll see there are only a handful of patterns: resume-screen pass, interview scheduling, rejection, offer. The skeleton of the message is the same — what changes is the candidate’s name and the client’s tone.

So register the messages you use most as “templates,” hand Claude Code the situation, and let it produce only the draft. What used to take 5–8 minutes of writing from scratch becomes 1–2 minutes of pouring details into a shape.

Before and after looks like this:

• Before: writing each one from zero while staring at the inbox. By evening, the prose gets sloppy.
• After: you hand over the situation as bullet points and a draft comes back. The human only does fact-checking and small tweaks.

Here’s the prompt template that produces the draft. Copy it as-is and just swap what’s inside the brackets.

You are an email-drafting assistant for a recruitment process outsourcing (RPO) team.
Using the conditions below, write a draft email to a candidate in English.

# Client tone
[e.g. polite and formal; avoid jargon]

# Email type
[one of: resume-screen pass / interview scheduling / rejection / offer]

# Situation
- Candidate handle: [pseudonym such as "Candidate A"]
- Position applied for: [e.g. account executive]
- What to convey this time: [first interview is June 12, 2pm, online]
- Note: [it's been 3 days since the last contact, so include a brief apology]

# Constraints
- Roughly 120–180 words
- Suggest a subject line too
- Do not put any personally identifying details in the body
- A human will review before sending, so add a bullet list at the end of points to double-check

Making it surface those “points to double-check” is the trick. When the AI self-reports the spots it’s unsure about, the human review takes seconds. If you want to sharpen how you build prompts, read advanced prompt engineering techniques too.

Use case 2: Surface stalled candidates every morning

The second win is detecting candidates who’ve gone quiet. The scariest thing in RPO is forgetting someone. Leave a candidate stuck three days waiting on a client’s evaluation and you risk both a lost opportunity and a dent in trust.

Don’t have the AI make this judgment — flag the gaps with a mechanical rule. That’s the safe approach. Keep candidate stage and last-update date in a CSV, then run a script to surface anyone who hasn’t moved in days.

The Node.js script below lists every candidate that hasn’t moved for three or more days. It uses no real names — it runs entirely on pseudonymous IDs by design. Put candidates.csv in the same folder and run it.

import { readFile } from "node:fs/promises";

// candidates.csv format:
// id,stage,lastUpdate,owner
// C001,resume-screen,2026-06-01,Masa
// C002,awaiting-first-interview,2026-06-05,Masa

const STALE_DAYS = 3;
const today = new Date("2026-06-07");

const raw = await readFile(new URL("./candidates.csv", import.meta.url), "utf8");
const rows = raw.trim().split("\n").slice(1); // drop the header

const stale = [];
for (const line of rows) {
  const [id, stage, lastUpdate, owner] = line.split(",").map((s) => s.trim());
  const days = Math.floor((today - new Date(lastUpdate)) / 86400000);
  if (days >= STALE_DAYS) {
    stale.push({ id, stage, owner, days });
  }
}

stale.sort((a, b) => b.days - a.days);

if (stale.length === 0) {
  console.log("No stalled candidates.");
} else {
  console.log(`Candidates idle for ${STALE_DAYS}+ days: ${stale.length}`);
  for (const c of stale) {
    console.log(`- ${c.id} / ${c.stage} / owner ${c.owner} / stalled ${c.days} days`);
  }
}

Running it is just this:

node check-stale.mjs

Hand the resulting list straight to Claude Code and ask, “From this stalled list, draft the reminder emails I should send today, grouped by stage,” and you’ve connected it back to Use case 1. The human judges, the machine does the tedious gap-detection, the AI does the writing. The roles split cleanly.

Use case 3: Lock per-client wording rules into CLAUDE.md

The third piece is the mechanism that stops you from mixing up tone across all those companies. My misfire at the top had the same root cause: Company A’s rules and Company B’s rules got blended together in my head.

You can prevent that by writing each client’s rules into a file and having the AI read it every time. With Claude Code, you put your project rules in CLAUDE.md and it references them automatically on every request.

For example, you’d write something like:

• Company A: very formal. Use “your organization.” No emoji. Reply same day.
• Company B: slightly casual. Always include one line acknowledging the candidate’s nerves.
• Shared: never promise salary or terms. Always offer multiple date options.

How to build this file out well is covered in CLAUDE.md best practices. Once the rules live in a file, the AI catches the mix-ups for you even when your brain is fried during a busy week.

As a post-rollout checklist, confirming the following before you send all but eliminates accidents:

• Does the recipient client match the tone of the message?
• Are the candidate’s handle and position correct?
• Are the date, location, and URL free of factual errors?
• Did you avoid promising salary or terms you weren’t authorized to?
• Did you avoid pasting any PII into your instructions to the AI?

A rough ROI, and the PII rules you can’t skip

Here’s a back-of-the-envelope time saving. At 100 candidate emails a week, at 7 minutes each before and 2 minutes after, you save about 8 hours a week — somewhere around 30 hours a month. Add the manual gap-checking you no longer do, and it pays off even harder during the busy season. It’s an estimate, but the real value is rolling those reclaimed hours into candidate conversations and client proposals.

On the other hand, tread carefully here. RPO is a job that handles mountains of personal data. Never paste a candidate’s real name, phone number, email, or date of birth straight into your instructions to the AI. Make this absolute.

Concretely, design it like this:

• Handle candidates with pseudonymous IDs like “Candidate A” or “C001.”
• Don’t feed contact details or resume contents to the AI — the human matches those up locally.
• If you also want to hide client names, swap them for “Company X” and the like.
• Check the terms of whatever service you use to confirm your input data isn’t used for training.

Running on pseudonyms is plenty for templatizing email and detecting stalls. If anything, keeping the personal data out makes the messages more generic as templates, so they reuse better.

FAQ

Q. Is it fine to have the AI send emails fully automatically? Don’t. RPO email can’t be unsent. Keep the line: the AI goes as far as the draft and the check-points, but the human presses send.

Q. Can I have the AI read and summarize a candidate’s resume? Be cautious from a personal-data standpoint. If you genuinely need a summary, hide the name and contact details and pass only the job content and years of experience. Confirm first that your client contract allows using an external AI.

Q. I can’t program. Can I still use the check script? Yes. You install Node.js and type one command. Start with environment setup in the Claude Code getting-started guide and you’re less likely to trip up.

Q. If I want to start small, where’s the first step? Rejection note drafts. The wording is formulaic and quietly draining to write every time. Templatizing just that visibly cuts the evening burnout.

What happened when I actually tried it

On my own machine, I built a CSV of 20 dummy candidates and ran the stale-detection script above. It surfaced 5 candidates stuck for 3+ days in one shot, and the misses I used to make eyeballing the list felt like a thing of the past.

For the email drafts, I wrote out Company A and Company B tones as CLAUDE.md-style rules and generated 10 messages. Zero tone mix-ups. What I noticed is that the “points to double-check” the AI tacks on at the end were more useful than I expected. It would add “please confirm the day of the week on the date matches the facts” every time, so the human review wrapped up in tens of seconds.

Conversely, a human judgment like whether a rejection reason actually holds up is, of course, not something you can hand off entirely. Keeping that with the human, exactly as the line drew it, turned out to be the right design.

If you’re an RPO team that wants to systematize the whole pipeline at the company level, the fast path is to work out the operating design together through training and rollout consulting. If you’d rather try it solo first, copy the stale-detection script and the prompt template above and run them against tomorrow morning’s inbox.

For external reference, the UK Information Commissioner’s Office guidance on recruitment and employment is worth checking to stay current on handling personal data.