Use Claude Code to Compare Recruitment Job Posts and Candidate Emails Before Sending

Recruitment agencies often fix the job post in one tab and the candidate email in another. That is where small mismatches survive. The job post says hybrid two days a week, but the candidate email says remote friendly. The salary range was copied from an old client note. The interview flow changed last week, but the mail draft still promises two steps. The first thing to fix today is not the entire recruiting operation. It is one comparison table before sending.

This article is for recruitment agency teams where RAs collect client information, CAs answer candidate concerns, and operations staff publish job pages or structured data. Claude Code is useful here as a comparison helper. It can read a sanitized job post, candidate email, client confirmation memo, common candidate questions, and JobPosting fields, then produce a mismatch table. It should not decide compensation, location, eligibility, contract terms, or whether the email is safe to send.

Reader card: the target industry is recruitment agencies. The reader is an RA, CA, or team lead who sends job descriptions and candidate emails. The current failure is that a candidate receives promises that do not match the job post. After reading, the reader compares one job post and one outgoing email across salary, location, remote policy, and interview flow. Claude Code prepares the table and questions. People approve facts, personal data handling, legal wording, client confirmation, and sending. The main CTA is training and consultation because this workflow touches team roles and approvals.

Key Points

• Job posts and candidate emails should be checked together across salary, location, remote policy, interview flow, work scope, and contract notes.
• Claude Code can compare sanitized materials and return mismatches, candidate concerns, and questions for the client.
• People review compensation, location, contract terms, age or gender wording, personal information, client approval, and the final send action.
• Three use cases cover condition mismatches, recurring candidate concerns, and emails that should be held before sending.
• Useful metrics are client rework count, candidate follow-up questions, interview conversion rate, resend count, and time to publish a job.

Workflow: One Table From Job Post To Candidate Email

A recruitment agency review starts with the artifacts the candidate will indirectly see. Put the job post, RA client memo, candidate email draft, recruiting platform fields, common candidate questions, and JobPosting JSON-LD in one working folder. Before Claude Code sees them, replace candidate names, current employers, evaluation notes, precise negotiation details, and private client information with placeholders.

Artifact	What Claude Code extracts	Human decision
Job post	salary, location, role scope, hiring process	client-confirmed facts
Candidate email	promises, vague phrasing, missing caveats	whether to send
RA memo	open questions and unconfirmed conditions	private client information
Candidate questions	FAQ and text to move upward	personal data handling
JobPosting data	location, salary, dates, validity	public structured data

Official sources should shape the checklist. Japan’s Ministry of Health, Labour and Welfare explains display requirements for recruitment advertising and notes that, from April 2024, items such as change scope for work duties, change scope for workplace, and renewal criteria for fixed-term contracts were added to information that needs to be clarified during recruitment. MHLW’s fair recruitment guidance is also useful when reviewing interview and candidate-facing language. If the job page uses structured data, Google’s JobPosting structured data documentation should match the visible job page.

What Claude Code Handles And What People Review

Once the job post, candidate email, and memo are in one folder, ask Claude Code for a mismatch table. The table should have rows such as salary, location, remote policy, interview count, start date, change scope of duties, and change scope of workplace. Each row compares the job post, email, client memo, and public data. Empty or conflicting cells become client questions, not invented copy.

People own the risky decisions. Compensation, workplace, remote frequency, contract term, renewal criteria, age or gender implications, candidate personal information, private client details, and final sending are human review points. Claude Code can say “this reads like a promise.” It cannot turn an unconfirmed condition into a candidate-facing promise.

Personal data deserves a separate boundary. Candidate names, current employer names, contact details, interview evaluations, and exact negotiation notes should not be pasted into the prompt. Use placeholder IDs such as Candidate A or C001. Check the official site of Japan’s Personal Information Protection Commission and your company’s contract or tool settings before operationalizing the workflow. The goal is to compare wording, not to expose sensitive data.

Three Use Cases

Use case 1: Find mismatches between the job post and outreach email

Input: job post, RA client memo, candidate outreach email, and recruitment platform fields. Output: a table of differences for salary, location, remote policy, interview count, start timing, and change scope. Human review: approve salary range, remote frequency, workplace, interview flow, and whether the client has confirmed the statement.

Candidate emails often drift toward the most attractive interpretation. A job post that says “hybrid, two days remote” becomes “flexible work style.” Claude Code should extract candidate-readable promises and place them beside the job post. The team then removes or qualifies anything that has not been confirmed.

Use case 2: Move repeated candidate concerns back into the job post

Input: common candidate questions, decline reasons, job post text, and follow-up email drafts. Output: FAQ items, text to move higher in the job post, email snippets, and questions for the client. Human review: remove personal information, candidate-specific evaluation, and unanswered client conditions.

If every email needs the same clarification, the job post is missing something. Questions such as “when does overtime happen,” “what experience qualifies for the top salary,” and “who conducts the first interview” belong near the job description or FAQ. This reduces back-and-forth before the candidate agrees to a conversation.

Use case 3: Hold emails that should not be sent yet

Input: outgoing email, job post, client approval list, risky wording list, and JobPosting JSON-LD. Output: a status table: send, hold for client confirmation, remove candidate data. Human review: recipient, name, timing, legal or platform wording, personal information, and final approval.

Polite copy is not enough. If the email and job post disagree, the email should stop. Claude Code should flag phrases that read like a promise. A person keeps only client-approved conditions and holds unresolved items before sending.

Copy-Paste Prompt

Use this prompt after replacing names and private details with placeholders. It asks Claude Code to compare artifacts before writing persuasive copy.

Act as a pre-send reviewer for a recruitment agency.
Compare the job post, candidate email, and client confirmation memo.
Find mismatches before the email is sent to a candidate.

Input:
- Job post:
- Candidate email:
- RA client confirmation memo:
- Common candidate questions:
- Recruitment platform fields:
- JobPosting JSON-LD:
- Human review requirements:

Output:
1. Conditions that differ between the job post and the email
2. Candidate-facing phrases that may sound like promises
3. Questions to send back to the client
4. Places to remove personal or private information
5. A status table: send / hold / revise
6. A final human review checklist

Constraints:
- Do not invent salary, location, remote policy, contract terms, or interview count
- Flag age, gender, family, birthplace, religion, or political wording
- Do not include candidate names, current employer names, contact details, or evaluation notes
- Treat the final send decision as a human action

The following Node.js check does not send anything. It catches missing job post fields, candidate-email inconsistencies, unapproved client memo items, risky wording, and a drifting CTA.

const reviewPacket = {
  jobPost: {
    role: "Customer Success",
    salary: "JPY 4.8M to 6.5M",
    location: "Tokyo office / two remote days per week",
    process: "screening, first interview, final interview",
    workChangeScope: "customer success, support, sales operations",
  },
  candidateEmail: {
    subject: "Customer Success opportunity",
    body: "This role is based in Tokyo with two remote days per week. The process is screening, first interview, and final interview.",
    cta: "sendToCandidate",
  },
  companyMemo: {
    salaryConfirmed: true,
    locationConfirmed: true,
    processConfirmed: true,
    clientApproval: true,
  },
};

const findings = [];
const { jobPost, candidateEmail, companyMemo } = reviewPacket;

for (const field of ["salary", "location", "process", "workChangeScope"]) {
  if (!jobPost[field]) findings.push(`${field}: missing in job post`);
}

if (!candidateEmail.body.includes("two remote days")) {
  findings.push("candidateEmail: remote policy may not match the job post");
}

if (!candidateEmail.body.includes("first interview") || !candidateEmail.body.includes("final interview")) {
  findings.push("candidateEmail: interview process is incomplete");
}

for (const [key, value] of Object.entries(companyMemo)) {
  if (value !== true) findings.push(`companyMemo: ${key} is not approved`);
}

const riskyWords = ["young team", "women only", "men only", "family background", "birthplace", "religion"];
for (const word of riskyWords) {
  if (candidateEmail.body.includes(word)) findings.push(`risky wording: ${word}`);
}

if (candidateEmail.cta !== "sendToCandidate") {
  findings.push("CTA should stay focused on candidate send review");
}

if (findings.length) {
  console.error(findings.join("\n"));
  process.exit(1);
}

console.log("Job post and candidate email are ready for human pre-send review.");

Pitfall: Mismatches Teams Miss Before Sending

The first pitfall is trusting polished copy. The cause is reviewing the job post, RA memo, candidate email, and platform fields in separate screens. The fix is to make one row per condition and compare the same words across every artifact.

The second pitfall is answering recurring candidate questions only in email. The cause is treating each question as a one-off reply. The fix is to split the answer into “move back to job post” and “candidate-specific note.” Repeated questions belong near the job description.

The third pitfall is letting AI output decide the send status. The cause is asking for a finished email before facts are confirmed. The fix is to keep Claude Code’s output as send, hold, or revise recommendations, then leave compensation, location, contract, personal information, and client approval to people.

Frequently Asked Questions

How is this different from a job posting review? A job posting review checks the job post itself. This workflow checks the gap between the job post and the candidate email before sending.

Can I paste candidate information into Claude Code? Do not paste names, current employers, contact details, interview evaluations, or exact negotiation notes. Use placeholder IDs and compare only the wording needed for review.

Can Claude Code do legal review? It should extract red flags, not make the final legal or publication decision. People review official guidance, platform rules, client confirmation, and the actual message.

Which metric should I watch first? Start with client rework count, candidate follow-up questions, interview conversion rate, and resend count. These reveal where wording diverges.

Consultation Path

This pre-send review is not only a writing task. It connects RA client confirmation, CA candidate context, platform fields, sending approval, and personal data handling. For teams using Claude Code across multiple recruiters, training and consultation can define what AI compares and what people approve.

Related Japanese-origin workflows include recruitment agency job posting review and job posting plus follow-up email for hiring teams. The external references used here are MHLW recruitment advertising guidance, MHLW April 2024 employment condition clarification guidance, MHLW fair recruitment selection basics, Google’s JobPosting structured data, and Japan’s Personal Information Protection Commission.

What I Verified

For this article I checked the official MHLW pages on recruitment advertising display, April 2024 employment condition clarification, fair recruitment selection, Google’s JobPosting structured data documentation, and the Personal Information Protection Commission site. I shaped the article around concrete artifacts: job post, candidate email, RA memo, candidate questions, and JobPosting fields. The main CTA stays on training and consultation because this workflow crosses team roles and approval rules.

I also ran the Node.js check code locally. It verifies job post fields, remote-policy wording, interview process, client memo approval, risky wording, and the candidate-send CTA. The next practical action is to take one outgoing candidate email and compare it with the job post across four columns: salary, location, remote policy, and interview flow. Then watch client rework count and candidate follow-up questions.