Write Recruiting Agency Job Posts and Candidate Outreach Faster with Claude Code

Friday afternoon, the recruiter sitting next to me had his head in his hands.

His desk had picked up twelve new reqs that week. Each one needed a polished job post, a shortlist of ten candidates, and a personalized outreach message for every name on that list. He couldn’t keep up, so he copy-pasted the body of an outreach message he’d sent before, swapped out the company name and the role, and hit send. The next morning a candidate replied: “The previous employer you listed isn’t mine.”

He’d forgotten to swap one field. If you’ve worked at a recruiting agency, you’ve probably done a version of this at least once. Outreach is a numbers game, but a single sloppy message destroys trust in one shot. I spent a while pushing this “volume vs. quality” tension as far as Claude Code could realistically take it. Today I’ll lay out the workflow in a copy-paste form.

Key takeaways

• For a recruiting agency, job posts and outreach get faster when you let Claude Code mass-produce the drafts and keep only the final judgment in human hands.
• This is not “throw it over the wall.” The trick is to hand over structured job data and candidate summaries, and to turn tone and banned phrasing into rules.
• For PII, hide names and contact info. Pass only role, experience, and skills, and set things up so the raw data is never used for training.
• Drafting ten outreach messages dropped from roughly 90 minutes to a little over 20 on my desk. The “forgot to swap the field” accident gets caught by a check script.
• I’ve included a copy-paste prompt template and a Node.js script that mechanically scans for the wrong company name leaking into a message.

Where the time actually leaks in a recruiting agency

The reader I have in mind is a full-desk or candidate-side recruiter. You carry 20 to 40 reqs solo, send a few dozen outreach messages a week, and still have intake calls with hiring companies. The time you actually get to sit and write copy is much thinner than it looks.

If you line up the recruiting workflow from a “writing copy” angle, it looks like this:

1. Run intake with the hiring company and capture the requirements
2. Turn those requirements into a job post for your job board or internal database
3. Search your database for candidates and filter by match
4. Write outreach (or a submission writeup) for each candidate
5. Wait for replies and move into interview scheduling

Steps 2 and 4 are the manual writing. A job post for the same role differs subtly company to company, and an outreach message won’t even get opened unless it includes one line of “why you specifically.” Do all of this by hand and it burns 2 to 3 hours per person per day.

Common rework and headaches

Here’s a table of the recurring rework I’ve heard about on the floor.

Headache	Cause	Result
Forgot to swap the company name or role in outreach	Copy-paste workflow	Trust gone, zero replies
Job post phrasing violates board policy	Age/gender-limiting language	Listing bounced back
The personalized line turns into boilerplate	No time, so it gets reused	Open rates drop
Phrasing is dated or wordy	Recycled old copy	Not read, candidate bounces

Every one of these happens in the gap between “the effort of writing from scratch” and “the temptation to sloppily copy-paste.” Claude Code fits squarely in that middle: build the foundation automatically, and leave only the final line and the fact-check to a human.

What to delegate to AI vs. decide yourself

Draw this line first, or you’ll have accidents. Here’s the rule I run by.

Step	Delegate to Claude Code	A human must decide
Polishing the job post	Draft of structure and phrasing	Salary, location, must-have facts
Board policy check	Flag risky phrasing	Final call on whether it can run
Outreach draft	The skeleton and the candidate line	Promises and any exaggeration to a candidate
Candidate summary	Tidying up the resume into key points	How PII is handled

There’s one principle. A human owns the facts and the promises. AI is great at writing “fast and plausible,” but it doesn’t know whether the role really pays $150K, or whether the candidate really has that skill. What you can hand to generative AI is phrasing, not facts. Confuse the two and you’ll get complaints over an exaggerated outreach message.

If this is your first time touching AI or Claude Code, skim Claude Code for non-engineers first. It’ll give you a feel for what can and can’t be delegated.

Use case 1: turn intake notes into a job-post draft

Intake notes from a hiring company are usually fragments of bullet points. Turning those into a readable job post is the first automation point.

Before you delegate, structure what you hand over. Throw the scattered notes in as-is and the AI will helpfully fill in the gaps, writing up benefits that don’t exist. The trick is to split the input into these fields:

• Role / position title
• Must-have and nice-to-have requirements (facts only)
• Salary range, location, employment type
• Why the role is open (growth hire, backfill, etc.)
• Phrasing that must never appear (age/gender limits, etc.)

When you do this, teach Claude Code your job-post template and banned phrasing as project rules so you don’t have to repeat the instructions every time. How to write a CLAUDE.md is a good reference for that.

Use case 2: mass-produce outreach from candidate summaries

This is the heart of it. You want one open-worthy line for each candidate. By hand it’s the most painful step, but once it’s structured it’s exactly the territory AI is good at.

Here’s a checklist of what every outreach message must contain. When a draft comes back, a human eyeballs it against this.

• Does the opening say specifically why you sent it to this person?
• Are the company name and role correct (no missed swaps)?
• No exaggeration or promises that don’t match the facts?
• No rude assumptions about the candidate’s background?
• Is the closing action (interview ask, etc.) narrowed to exactly one?

Writing ten by hand, one at a time, took 90 minutes. Structuring the summaries, generating drafts in one batch, and fixing them against the checklist above got me down to a little over 20 minutes.

Use case 3: self-checking board policy and phrasing

Job posts and outreach contain phrasing you should avoid under employment law and job-board policy. Age/gender-limiting language like “young talent welcome” or “great fit for men” is the classic case. Let Claude Code do a first-pass check on this.

That said, the final call is human. The AI’s flags are a “don’t-miss-it alert,” not a guarantee of legal compliance. Treat them strictly as an aid to the human eye.

Copy-paste outreach prompt template

Here’s a prompt you can paste and use as-is. Put the candidate info in with names and contact details stripped out.

You are a writing assistant for a recruiting agency consultant.
Draft an outreach message under the conditions below.

# Job info
- Company: (paste the official name as-is)
- Role:
- Must-have requirements:
- Selling points: (facts only, no exaggeration)

# Candidate summary (do NOT include name or contact details)
- Current role and industry:
- Key experience and skills:
- Likely motivations:

# Output rules
- 120-180 words. Open by stating specifically why you're reaching out to this person.
- Do not invent achievements or compensation. Do not inflate promises.
- Do not use age- or gender-limiting language.
- Narrow the closing action to one: a casual-chat invitation.
- Use the company name and role exactly as given; do not alter them.

The whole prompt hinges on the last two lines. Force it to narrow the action to one, and stop it from altering the company name and role. Those two rules alone change reply rates and accident rates a lot. If you want to push prompt precision further, pair this with advanced prompt engineering.

A check script that mechanically stops the missed swap

That company-name leak from the opening story? Human eyes alone will let it happen again. So we mechanically check the finished outreach for a “company name that shouldn’t be there.” It’s a small script that runs on Node.js. Put the draft in scout.txt and the company names allowed this time in allow.json, then run it.

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

// Allow list: { "company": "correct company name", "ng": ["company names from past reqs, etc."] }
const allow = JSON.parse(await readFile(new URL("./allow.json", import.meta.url), "utf8"));
const text = await readFile(new URL("./scout.txt", import.meta.url), "utf8");

const problems = [];

// 1. Is the correct company name present in the body?
if (!text.includes(allow.company)) {
  problems.push(`The correct company name "${allow.company}" is missing from the body`);
}

// 2. Did a forbidden company name sneak in? (missed-swap detection)
for (const ng of allow.ng ?? []) {
  if (text.includes(ng)) {
    problems.push(`Banned company name "${ng}" is still present. Likely a missed swap`);
  }
}

// 3. Any age/gender-limiting phrasing?
const banned = ["young talent", "men only", "women only", "twenties only"];
for (const word of banned) {
  if (text.toLowerCase().includes(word)) problems.push(`Risky phrase "${word}" is present`);
}

if (problems.length === 0) {
  console.log("Check OK: passed the pre-send mechanical review");
} else {
  console.log("Send halted. Fix the following:");
  for (const p of problems) console.log(" - " + p);
  process.exit(1);
}

Running it is just this.

node check-scout.mjs

An example allow.json looks like this.

{
  "company": "Sample Inc.",
  "ng": ["company from the last req", "company from another req"]
}

If there’s a problem it exits with code 1 and stops, so wiring it into your send flow makes “sending with the field un-swapped” physically impossible. My colleague’s accident from the opening would have been prevented by this. Installing Claude Code itself takes 10 minutes if you follow getting started with Claude Code.

PII and security notes

A recruiting agency, by its nature, handles the single most sensitive kind of personal data: a person’s career history. Get sloppy here and “efficiency” turns into an incident. Here are the rules I keep.

• Never hand the AI names, phone numbers, emails, or an identifiable current department. Give it only role, years of experience, and skills.
• Don’t paste candidate-identifying info into a service outside your company’s control. Use AI under a contract and setting where your input data is never used for training.
• Before sending any generated draft, a human must always verify the facts and proper nouns.
• For a hiring company’s non-public information (confidential reqs and the like), don’t go beyond what you’ve agreed with the company.

For primary sources on phrasing and handling of personal data, the U.S. EEOC guidance on employment discrimination is a solid reference. Combine it with each job board’s policy and bake it into your own internal rules.

Before and after (a rough ROI)

These numbers are my own rough estimates, so treat them as a reference point.

Item	Before	After
Drafting 10 outreach messages	~90 min	~20 min
Polishing one job post	~30 min	~10 min
Forgotten company-name swap	Happens occasionally	0, caught by check script

That’s about 70 minutes saved per ten outreach messages. Send 30 a week and roughly 3+ hours move over to actual candidate conversations and intake. A recruiting agency’s value isn’t in writing copy; it’s in reading people and companies. The real win is putting the reclaimed time back there.

FAQ

Q. Can I send the job posts and outreach the AI wrote as-is? No. Use them as drafts, and a human must always verify the facts and proper nouns: company name, salary, requirements. The AI doesn’t know the facts.

Q. Can you really write good outreach without giving the AI the candidate’s name and contact info? Yes. What outreach needs is “why send it to a person with this background,” and role, experience, and skills cover that. Name and contact info have nothing to do with copy quality.

Q. Won’t every message come out looking identical? Not if you pass a structured candidate summary one person at a time; the opening line changes. The boilerplate feel shows up when you lazily mash a summary together and throw it in.

Q. We don’t have an IT department. Can we even run the check script? Install Node.js and it runs in a few lines. If that’s tough, you can talk it through with your internal process-improvement lead via training and consulting.

What happened when I actually tried it

I tested this with fictional data modeled on real reqs, producing three job posts and ten outreach messages. I was checking three things.

First, the drafting time for ten outreach messages. Against a felt 90 minutes by hand, passing structured summaries dropped it to a little over 20. The opening line lost its boilerplate smell as long as I varied each person’s summary.

Second, whether the check script actually works. I deliberately mixed in four drafts with a previous req’s company name left in, and all four exited with code 1 and stopped. It caught the age-limiting phrasing too. Relying on human eyes alone, I’d have certainly missed a few.

Third, whether quality drops without PII. Stripping out name and contact info and passing only role and experience didn’t change how persuasive the outreach was. If anything it kept the core, “this part of your background is what drew me,” and read more cleanly.

The conclusion: for recruiting outreach, a three-stage setup, “AI drafts, a human owns the facts and the line, a machine does the final check,” was far more realistic than “full automation.” If you want to bake it into company workflows, start from training and consulting; if you’d rather get your own hands dirty first, start from learning materials and the free PDF.