AI for HR and Recruiting 2026

Talent acquisition teams using AI well are filling roles 40% faster while improving quality of hire. Here's the complete playbook.

Job Description Optimization

python
import anthropic
client = anthropic.Anthropic()
def optimize_job_description(
    role_title: str,
    raw_requirements: str,
    company_culture: str,
    location_policy: str
) -> dict:
    response = client.messages.create(
        model='claude-sonnet-4-5',
        max_tokens=3000,
        messages=[{
            'role': 'user',
            'content': f"""Optimize this job description for quality candidate attraction.
Role: {role_title}
Raw requirements: {raw_requirements}
Company culture: {company_culture}
Location policy: {location_policy}
Create:
SEO-optimized job title (what candidates actually search for)
Compelling introduction (why someone should care about this role)
What you'll do (impact-focused, not task lists)
What we're looking for:
   - Must-have requirements (5 or fewer, truly essential)
   - Nice-to-have skills (separate from must-have!)
What we offer (specific, not vague 'competitive salary')
Inclusion statement
Also:
Flag any requirements that might unnecessarily exclude candidates
Suggest A/B test variants for the headline
Estimated time to fill based on requirements scope
Return as JSON."""
        }]
    )
    text = response.content[0].text
    return json.loads(text[text.find('{'):text.rfind('}')+1])

Resume Screening Automation

python
def screen_resume(
    resume_text: str,
    job_requirements: dict,
    scoring_criteria: dict
) -> dict:
    must_haves = ', '.join(job_requirements.get('must_have', []))
    nice_haves = ', '.join(job_requirements.get('nice_to_have', []))
    
    response = client.messages.create(
        model='claude-sonnet-4-5',
        max_tokens=1500,
        messages=[{
            'role': 'user',
            'content': f"""Screen this resume against job requirements objectively.
Must-have requirements: {must_haves}
Nice-to-have skills: {nice_haves}
Resume:
{resume_text[:10000]}
Return JSON:
{{
  "overall_score": 0-100,
  "recommendation": "strong_yes|yes|maybe|no",
  "must_have_met": {{
    "requirement_name": {{"met": true/false, "evidence": "quote from resume"}}
  }},
  "nice_to_have_met": {{}},
  "red_flags": ["any concerns"],
  "standout_factors": ["what's impressive"],
  "suggested_interview_questions": ["2-3 role-specific questions based on resume"]
}}"""
        }]
    )
    text = response.content[0].text
    return json.loads(text[text.find('{'):text.rfind('}')+1])
Process 100 resumes
for resume in resume_pile:
    score = screen_resume(resume['text'], job_req, scoring_criteria)
    if score['recommendation'] in ['strong_yes', 'yes']:
        schedule_interview(resume['candidate_id'])

Interview Question Generation

python
def generate_interview_questions(
    role: str,
    competencies: list,
    candidate_background: str,
    interview_type: str
) -> list:
    competencies_str = '\n'.join([f'- {c}' for c in competencies])
    
    response = client.messages.create(
        model='claude-sonnet-4-5',
        max_tokens=3000,
        messages=[{
            'role': 'user',
            'content': f"""Generate structured interview questions for a {role} role.
Interview type: {interview_type}
Competencies to assess:
{competencies_str}
Candidate background: {candidate_background}
For each competency, provide:
Behavioral question (STAR format)
Follow-up probes (2-3)
What a strong vs. weak answer looks like
Also generate:
2 technical/skills questions relevant to role
1 culture/values question
Closing: candidate questions to expect and suggested responses
Avoid: leading questions, illegal questions (family status, age, origin)"""
        }]
    )
    return response.content[0].text

Onboarding Automation

python
def create_onboarding_plan(
    new_hire_role: str,
    new_hire_background: str,
    team_context: str,
    company_info: str
) -> str:
    response = client.messages.create(
        model='claude-sonnet-4-5',
        max_tokens=4000,
        messages=[{
            'role': 'user',
            'content': f"""Create a 30-60-90 day onboarding plan.
New hire: {new_hire_role}
Background: {new_hire_background}
Team context: {team_context}
Company info: {company_info}
Create:
Day 1 agenda (detailed hour-by-hour)
Week 1 priorities
30-day milestones (learning + first contributions)
60-day milestones (independent work)
90-day milestones (full productivity)
For each period: what they should KNOW, DO, and FEEL.
Include success metrics for each milestone."""
        }]
    )
    return response.content[0].text

Bias Reduction in Hiring

python
def audit_for_bias(
    hiring_decision: str,
    decision_rationale: str
) -> str:
    response = client.messages.create(
        model='claude-sonnet-4-5',
        max_tokens=1000,
        messages=[{
            'role': 'user',
            'content': f"""Audit this hiring decision for potential bias.
Decision: {hiring_decision}
Rationale: {decision_rationale}
Check for:
Words suggesting affinity bias (similar to us, culture fit without specifics)
References to protected characteristics
Vague reasoning that could mask bias
Inconsistent standards vs. similar candidates
Return: specific concerns + rewording suggestions where needed."""
        }]
    )
    return response.content[0].text

Metrics Impact

MetricBefore AIAfter AI

Time to fill45 days28 days Applications screened/day20200 Interview no-shows18%9% 90-day retention71%84%

Legal Considerations

AI screening must comply with EEOC and local employment law

Audit AI tools for adverse impact on protected classes

Human review required for all final hiring decisions

Document your screening criteria and maintain consistency

Conclusion

AI transforms recruiting by handling the volume work (screening, scheduling, JD writing) so recruiters can focus on relationship-building, culture assessment, and candidate experience. The teams winning use AI as a filter and assistant, not a decision-maker.