Best ChatGPT Prompts for Recruiters (2026)

The single highest-leverage recruiting prompt is one that generates a tight Boolean string you can paste directly into LinkedIn Recruiter, GitHub search, or Google X-Ray. Most AI-generated booleans are either too broad (returning 10,000 noisy profiles) or too narrow (returning 12). The key is giving the model explicit constraints on seniority, must-have skills, and explicit exclusions.

**Prompt — LinkedIn Recruiter Boolean:** ``` You are a senior technical recruiter specializing in software engineering talent acquisition. Generate a LinkedIn Recruiter Boolean search string for a [ROLE TITLE] position with these requirements: - Must-have skills: [SKILL 1], [SKILL 2], [SKILL 3] - Preferred skills: [SKILL 4], [SKILL 5] - Seniority: [YEARS] years minimum, exclude interns and students - Location: [CITY/REGION], open to remote from [COUNTRIES] - Industry: [INDUSTRY], exclude [EXCLUDED INDUSTRY] - Title variations to include: [ALT TITLE 1], [ALT TITLE 2] - Exclude titles: [EXCLUDE TITLE 1], [EXCLUDE TITLE 2] Output: One optimized Boolean string using AND, OR, NOT operators and parentheses grouping. Then explain each clause in 1 sentence each. ```

**Prompt — Google X-Ray sourcing for GitHub profiles:** ``` Generate a Google X-Ray search string to find GitHub profiles of [ROLE] engineers who have public repositories in [TECH STACK]. The person should appear to have worked on [TYPE OF PROJECT]. Include the site: operator targeting github.com/[username pattern]. Output the raw search string only, then a second version adding filetype:pdf to surface any linked resumes. ```

**Why this works:** Specifying output format (Boolean string, then clause explanations) prevents the model from producing a paragraph of advice instead of a usable search string. Claude Opus 4 tends to over-explain; adding 'output the raw string only' on the first line fixes this across all models.

Generic job descriptions attract generic candidates. A prompt that forces the model to write from a specific company voice, with real qualifications and concrete impact statements, produces JDs that outperform boilerplate by measurable apply-rate margins.

**Prompt — Full JD from scratch:** ``` Write a job description for [JOB TITLE] at [COMPANY NAME], a [COMPANY DESCRIPTION IN 1 SENTENCE]. Details: - Team: [TEAM NAME], [TEAM SIZE] people, reports to [MANAGER TITLE] - Location/remote: [DETAILS] - Comp range: [RANGE] (include if given, skip if not) - Must-have qualifications: [LIST 3-5] - Nice-to-have: [LIST 2-3] - Top 3 things this person will own in the first 90 days: [LIST] - Company voice: [e.g., direct, no corporate jargon, founder-tone] Format: 1. One-paragraph role summary (no buzzwords like 'dynamic' or 'passionate') 2. What you'll do (5-7 bullet points, concrete verbs) 3. What we're looking for (hard requirements, then preferred) 4. What makes this role worth taking (honest, specific) 5. How to apply (1-2 sentences) Do not use the phrases: 'fast-paced', 'wear many hats', 'self-starter', 'passionate', 'rockstar', 'ninja'. ```

**Prompt — Rewrite existing JD to reduce bias:** ``` Rewrite the following job description to reduce gender-coded language and unnecessary credential requirements that do not predict job performance. Preserve all technical requirements. Flag any requirement you removed or softened and explain why in a table below the rewrite. Original JD: [PASTE JD HERE] ```

For teams publishing at scale, the best ChatGPT prompts for HR post covers the full HR content workflow including policy documents, onboarding materials, and performance review templates.

Cold outreach response rates correlate directly with how specific the message is. A message that references a candidate's actual project, publication, or career trajectory outperforms a template-y message by 3-5x in controlled A/B tests across recruiting platforms. The prompt below generates a personalized message from raw profile notes — not a mail-merge.

**Prompt — LinkedIn InMail / cold outreach:** ``` Write a personalized LinkedIn outreach message for a recruiter to send to a candidate. Candidate profile notes: - Name: [NAME] - Current role: [TITLE] at [COMPANY] - Notable: [1-2 specific things from their profile, e.g., led migration to Kubernetes, published paper on X, open source project Y] - Career trajectory: [BRIEF PATTERN, e.g., moved from IC to TL at two companies] Role being pitched: - Title: [ROLE TITLE] at [COMPANY] - Why this role is a fit for their background: [SPECIFIC REASON] - One thing that makes this role genuinely different: [HONEST DIFFERENTIATOR] Constraints: - Max 100 words - First sentence must not start with 'I' - Do not use 'excited', 'thrilled', or 'amazing opportunity' - End with a low-friction ask (15-min call, not 'let me know if you're interested') - Write in a direct, peer-to-peer tone — not recruiter-corporate Output: The message only, no explanation. ```

**Prompt — Follow-up sequence (3 messages):** ``` Write a 3-message follow-up sequence for a recruiter who has already sent the initial outreach below to a candidate who hasn't responded. Each message should be shorter than the last. Message 2 adds one new piece of value (team news, role update, or relevant content). Message 3 is a graceful close that leaves the door open. Initial message sent: [PASTE MESSAGE] Candidate name: [NAME] Role: [ROLE TITLE] Output: Message 2 and Message 3, labeled, each under 60 words. ```

Phone screen questions should be job-specific, structured, and calibrated to surface whether the candidate has done the work — not just knows the theory. Generic questions ('Tell me about yourself') produce generic answers. The prompt below generates a structured screen guide that a non-technical recruiter can use to screen for a technical role.

**Prompt — Structured phone screen guide:** ``` Create a structured phone screen guide for a [JOB TITLE] role at a [COMPANY TYPE] company. The recruiter conducting the screen is not technical. The role requires expertise in: [SKILL 1], [SKILL 2], [SKILL 3]. Key things we need to validate: 1. [VALIDATION CRITERIA 1, e.g., Has shipped production code, not just toy projects] 2. [VALIDATION CRITERIA 2, e.g., Has worked in fast-moving orgs without heavy process] 3. [VALIDATION CRITERIA 3, e.g., Can explain technical decisions to non-technical stakeholders] Output: - 8-10 questions, organized by category - For each question: the question text, what a strong answer looks like (2-3 sentences), and one red flag to listen for - End with 2 questions the candidate should ask us (and what bad answers to those look like) ```

**Prompt — Technical take-home screener (async, no live coding):** ``` Design a take-home technical assessment for a [ROLE TITLE] position. Requirements: - Completable in under 2 hours by a qualified candidate - Tests real job skills, not trivia or whiteboard-style puzzles - Evaluatable by a hiring manager in under 20 minutes - Must include a rubric with 4 performance levels per criterion Role context: [WHAT THE PERSON WILL ACTUALLY DO IN THE JOB] Skills to assess: [SKILL 1], [SKILL 2], [SKILL 3] Output: Assessment brief (candidate-facing), evaluation rubric (internal-only), and suggested time budget. ```

Unstructured interviews have weak predictive validity. Structured interviews with calibrated scorecards substantially outperform them. The problem is that building a good scorecard takes time that most hiring managers don't have. These prompts produce a calibrated scorecard in minutes.

**Prompt — Full interview scorecard:** ``` Create a structured interview scorecard for a [JOB TITLE] role. Competencies to evaluate (list up to 6): 1. [COMPETENCY 1, e.g., Problem decomposition] 2. [COMPETENCY 2, e.g., Cross-functional communication] 3. [COMPETENCY 3, e.g., Ownership under ambiguity] 4. [COMPETENCY 4] 5. [COMPETENCY 5] 6. [COMPETENCY 6] For each competency, generate: - 2 behavioral interview questions (STAR format) - A 4-level scoring rubric (1 = does not meet bar, 2 = approaching, 3 = meets, 4 = exceeds) - One observable indicator per level - An interviewer note field Output as a structured table. Include a summary section at the bottom with: Overall recommendation (Strong Yes / Yes / No / Strong No), key strengths, key concerns, and hiring committee discussion questions. ```

**Prompt — Calibration exercise for new interviewers:** ``` Create a calibration exercise for a new interviewer joining the hiring panel for [ROLE TITLE]. Include: 1. A sample candidate transcript excerpt (3-4 exchanges on [SKILL BEING ASSESSED]) 2. Three different interpretations of that answer (one too generous, one calibrated, one too harsh) 3. The correct score on our rubric and why 4. A reminder of the most common rating biases that inflate scores in this type of interview Make the transcript realistic — not obviously good or obviously bad. ```

See AI for HR teams for how to integrate AI-generated scorecards into your existing ATS workflow without creating compliance risk.

Before writing any sourcing string or JD, it helps to have a crisp model of who you are actually looking for. Recruiting teams that skip this step often discover halfway through a search that the hiring manager had a different person in mind than the recruiter was sourcing for. This prompt generates a candidate persona from a hiring manager conversation or job intake form.

**Prompt — Candidate persona from intake notes:** ``` You are a recruiting strategist. Based on the hiring manager intake notes below, build a detailed candidate persona. Intake notes: [PASTE NOTES FROM INTAKE CALL OR INTAKE FORM] Output the persona in this format: 1. WHO THEY ARE: Professional background in 3-4 sentences. Where do they currently work? What's their title? What stage company? 2. WHAT MOTIVATES THEM TO MOVE: Top 2-3 reasons this person would leave their current role. 3. WHERE TO FIND THEM: Top 3 sourcing channels with specific search angles for each. 4. HOW TO PITCH THEM: The 2-3 things about this role that would genuinely excite this persona — and 1 thing that might be a turn-off and how to address it honestly. 5. WHAT DISQUALIFIES THEM: Hard filters that would make this person wrong for the role even if they look right on paper. 6. COMMON PROFILE MISTAKES: Types of candidates that look like this persona but aren't — and the signal to distinguish them. ```

**Prompt — Sourcing strategy from persona:** ``` Given the following candidate persona, generate a 30-day sourcing plan. Include: outbound channels ranked by expected yield, search queries for each channel, estimated volume of qualified candidates per channel, and a weekly activity breakdown. Be specific — list actual community names, conference names, GitHub organization names, or Slack workspace names where relevant. Persona: [PASTE PERSONA OUTPUT FROM ABOVE] Role: [ROLE TITLE] Timeline: Must close in [X WEEKS] ```

Candidate experience is a recruiting KPI that most teams ignore until it bites them — on Glassdoor, on LinkedIn, or in the form of a referred candidate who declines because a friend had a bad experience. A well-written rejection at the right stage is a brand asset. These prompts generate stage-appropriate rejections that are honest and respectful.

**Prompt — Post-application rejection (no interview):** ``` Write a post-application rejection email for a candidate who applied to [ROLE TITLE] but did not advance to interview. Context: - We received [NUMBER] applications for this role - This candidate was not selected because: [REAL REASON — be specific for internal use, the email should be honest but not specific enough to invite a debate] - The company is [COMPANY NAME] - Tone: warm, brief, respectful — not corporate boilerplate Constraints: - Under 100 words - Do not say 'we had many qualified candidates' - Do not say 'we'll keep your resume on file' unless that is literally true - Do close the loop cleanly — no false hope, but no harshness ```

**Prompt — Post-final-round rejection (late-stage):** ``` Write a post-final-round rejection email for a candidate who made it to the final round for [ROLE TITLE] but was not selected. Context: - They interviewed with [NUMBER] people over [NUMBER] rounds - The decision was [BRIEF HONEST REASON — e.g., we went with someone who had more domain-specific experience in X] - This person was strong and we'd consider them for future roles: [YES/NO] - Recruiter name: [NAME] Requirements: - Acknowledge the time they invested specifically - Share one piece of genuine, constructive feedback if possible - If we'd consider them again, say so directly with specifics — not as a platitude - Under 150 words - Do not use 'this was a difficult decision' ```

For a broader suite of HR communication templates, see best ChatGPT prompts for HR and best ChatGPT prompts for startups — the startup guide covers lean-team hiring communications end to end.

Offer letters are legal documents, and AI should not be your final legal review. But AI is excellent at drafting the first version, ensuring nothing is omitted, and writing the accompanying offer summary email that actually gets read. Use these prompts to draft — then route through legal before sending.

**Prompt — Offer summary email (the email that accompanies the formal letter):** ``` Write an offer summary email from a recruiter to a candidate who has verbally accepted the [ROLE TITLE] position. Offer details: - Start date: [DATE] - Base salary: [AMOUNT] / [PERIOD] - Equity: [SHARES/OPTIONS/RSUs], vesting schedule [DETAILS] - Bonus: [TARGET AMOUNT/PERCENTAGE] at [FREQUENCY] - Benefits highlights: [TOP 2-3 BENEFITS] - Signing bonus (if any): [AMOUNT], [CONDITIONS] - Offer expiration: [DATE] Tone: Celebratory but professional. This is a person we want to join and we want them to feel good about saying yes. Include: A clear 'what happens next' section with 3-4 concrete next steps and who owns each one. Do not pad the email — cut anything that isn't useful to the candidate. ```

**Prompt — Counter-offer response guidance:** ``` A candidate we've extended an offer to has come back with a counter-offer. Help me think through the response. Our offer: [DETAILS] Their counter: [DETAILS] Our flex: [WHAT WE CAN AND CANNOT MOVE ON] Our read on their priority: [WHAT THEY SEEM TO CARE ABOUT MOST] Give me: 1. A negotiation analysis: what's their most likely real interest vs. stated position? 2. The strongest response that gets to yes within our constraints 3. Two alternative structures if we can't meet their number (e.g., accelerated review date, signing bonus vs. base, extra PTO) 4. Draft language for the verbal counter-conversation (not an email — the actual talking points for a call) ```

Not every recruiting prompt needs a frontier model. Understanding where each model excels in recruiting workflows lets you cut costs significantly — use our AI Prompt Cost Calculator to estimate the cost difference before running at scale.

**GPT-5 family (openai.com/pricing):** GPT-5 mini excels at high-volume structured tasks — rejection email generation, screening question lists, Boolean string drafts. GPT-5 standard handles JD writing and outreach generation well. GPT-5 pro is overkill for most recruiting tasks but justified for complex scorecard design where reasoning quality directly affects hiring decisions. The GPT-5 family also has the widest tool-calling support, making it the natural choice if you're automating a recruiting workflow end-to-end.

**Claude Opus 4 (anthropic.com/pricing):** Claude consistently produces the most nuanced candidate outreach messages and offer letter prose — the writing quality is noticeably higher on communication-heavy tasks. It's also notably better at holding a consistent tone across a long document (full JD, full offer letter) without drifting. For detailed persona building where you want the model to read between the lines in intake notes, Claude Opus 4 regularly outperforms GPT-5 standard. See best Claude prompts for recruiters for Claude-specific prompt tuning.

**Gemini 2.5 Pro (ai.google.dev/pricing):** Gemini 2.5 Pro has a very large context window and is strong at processing long documents — useful if you're feeding it a 50-page job family framework and asking it to generate 20 JDs at once, or processing an ATS export with hundreds of candidate records. Its multimodal capabilities also make it the best choice if your recruiting workflow involves parsing resumes in PDF or image format. For the ChatGPT vs Claude for hiring decisions full breakdown, see our dedicated comparison.

Individual prompts are useful. Chained workflows are transformative. The pattern that works for talent teams is: intake call → candidate persona → Boolean string → outreach draft → screening guide — all chained so that the output of each step feeds the next without re-entering context.

**Prompt — Master chain orchestrator:** ``` You are an AI recruiting assistant. I will give you a new hire intake form. From this single input, produce all of the following in order: 1. CANDIDATE PERSONA (format: who they are, where to find them, how to pitch them, what disqualifies them) 2. LINKEDIN BOOLEAN STRING (optimized, with clause explanations) 3. GOOGLE X-RAY STRING (targeting GitHub profiles) 4. OUTREACH MESSAGE TEMPLATE (personalized structure, 100 words, with [PLACEHOLDER] for candidate-specific details) 5. PHONE SCREEN GUIDE (6 questions, what a strong answer looks like, one red flag per question) 6. JOB DESCRIPTION DRAFT (following the standard 5-section format: summary, responsibilities, requirements, why join us, how to apply) Label each section clearly. Do not skip any section. After section 6, include a QUALITY CHECK section where you flag any inconsistencies between the persona, the JD, and the screening guide. Intake form: [PASTE INTAKE FORM HERE] ```

**Workflow tip:** Run this chain on GPT-5 standard or Claude Opus 4 Sonnet (not the full Opus 4) to balance quality and cost. The quality check section at the end is where frontier models earn their keep — it catches cases where the JD requires 5 years of experience but the persona describes someone 3 years into their career. Use the AI Prompt Cost Calculator to estimate per-hire costs before deciding which model tier to run in production.

AI can help surface bias in recruiting materials — but it can also introduce new bias if used carelessly. These prompts are designed to use AI as an auditor and expander, not as a decision-maker on individual candidates.

**Prompt — Audit JD for exclusionary language:** ``` Audit the following job description for language that may exclude qualified candidates from underrepresented groups. Check for: - Gender-coded language (research-backed lists, e.g., 'dominant', 'aggressive' as masculine-coded; 'collaborative', 'nurturing' as sometimes signaling culture-fit bias) - Unnecessary degree requirements (does the task actually require a degree?) - Implicit seniority bias in 'years of experience' requirements vs. demonstrated skill - Culture-fit language that may screen out neurodiverse candidates or people from different professional cultures - Geographic or schedule assumptions that disadvantage caregivers For each flag: quote the original text, explain the issue, and suggest a rewrite. JD: [PASTE JD] ```

**Prompt — Expand sourcing to underrepresented talent pools:** ``` I am sourcing candidates for [ROLE TITLE] and want to expand beyond my usual LinkedIn Recruiter searches to reach underrepresented talent. Suggest: 1. Five specific online communities, forums, or organizations where underrepresented [ROLE TYPE] professionals are active — with names and URLs 2. Three HBCU or minority-serving institution programs that produce [ROLE TYPE] graduates 3. Two conference or event names where I could build a sourcing pipeline 4. One non-obvious sourcing channel I'm probably not using Be specific — name the actual communities, not generic categories. ```

Teams using AI at scale across recruiting workflows should read AI for HR teams for coverage of compliance, data retention, and the governance questions that recruiting AI use raises at the organizational level.

Recruiting prompts fail for predictable reasons. Understanding the failure modes helps you fix them faster and build a library of prompts that work reliably across different roles and contexts.

The most common failure: **not specifying output format.** A prompt asking for 'interview questions' will produce a paragraph of advice about interview best practices, then 3 generic questions, then more advice. Always specify: number of outputs, structure of each output, and what to omit. Adding 'do not include any preamble or explanation' before 'Output:' cuts token waste by 30-50% and makes output immediately usable.

The second failure: **context under-specification.** 'Write a job description for a software engineer' produces something usable for approximately zero companies. The minimal viable context for a JD prompt is: role title, company one-liner, team size and structure, 3 hard requirements, and company voice. With that context, even GPT-5 mini produces JDs that need only light editing.

The third failure: **not separating internal and external outputs.** A scorecard rubric is an internal document; a candidate rejection email is external. Mixing them in a single prompt produces output that's either too blunt for candidates or too vague for interviewers. Run them as separate prompts, or explicitly label which sections are internal-only in your prompt.

Finally: **use the model's reasoning to QA itself.** Appending 'Before you output this, check: does the screening guide match the JD requirements? Does the outreach message match the candidate persona? Flag any misalignment.' costs a few hundred tokens and catches errors that would otherwise make it into your actual recruiting materials. This self-review pattern works well across all three major models tested.