Screening AI-Written Resumes Fairly: Adding AI Detection to a Hiring Pipeline

Recruiters are getting buried in polished, AI-written applications. If you build HR or applicant-tracking tools, you've probably been asked to "add AI detection".

It's a reasonable request, but it's also one of the easiest places to build something unfair. In this post we'll look at what the data says, build a small Python pipeline that scans resumes and flags them for human review (not rejection), and cover the guardrails that hiring tools need.

What the data says

A Checkr survey of 1,000 US business leaders, run in April 2026, found that:

• 73% of companies have encountered AI-generated resumes, cover letters or assessments, and 29% say it happens frequently
• 62% agree AI has made traditional resume screening obsolete
• Their top concern is AI-generated resumes that exaggerate or fabricate experience (36%), ahead of AI-completed skills tests (20%) and real-time AI help in video interviews (17%)
• 71% would invest in AI detection tools for hiring if they proved reliable

(Checkr sells background checks, so read vendor surveys with that in mind. The trend matches what recruiters tell us, though.)

First, decide what you're actually detecting

Using AI to polish a resume isn't cheating. Many good candidates use it to fix grammar or formatting. The real hiring risks are:

1. Fabricated experience: claims that aren't true
2. Mass-generated, untailored applications sent to hundreds of roles
3. AI-completed assessments that are meant to show the candidate's own skill

An AI-text score can't prove any of these. What it can do is tell a recruiter where to look more closely, for example by preparing specific interview questions about a section that reads as generic.

So the goal of our pipeline is prioritising human attention, not filtering people out.

The pipeline

resumes/*.pdf  →  extract text  →  detect AI  →  review_queue.csv

You'll need pdfplumber and requests:

pip install pdfplumber requests

Step 1: Extract text from PDFs

# extract.py
import pdfplumber

def pdf_text(path: str) -> str:
    with pdfplumber.open(path) as pdf:
        pages = [page.extract_text() or "" for page in pdf.pages]
    return "\n".join(pages).strip()

Scanned resumes (images of text) will come back empty. Flag those for manual handling instead of guessing.

Step 2: Score each resume

This uses the same helper as our earlier API tutorial. Any detection API with a probability score will work.

# detect.py
import os
import requests

API_URL = "https://ai.proofai.in/api/v1/detect"

def detect_ai(text: str) -> dict:
    resp = requests.post(
        API_URL,
        headers={
            "x-api-key": os.environ["PROOFAI_API_KEY"],
            "Origin": os.environ["PROOFAI_ORIGIN"],
        },
        data={"content": text},
        timeout=20,
    )
    resp.raise_for_status()
    return resp.json()

Step 3: Build a review queue, not a reject list

# scan_resumes.py
import csv
import time
from pathlib import Path
from extract import pdf_text
from detect import detect_ai

MIN_WORDS = 80          # resumes are short; demand enough text
REVIEW_THRESHOLD = 85   # tune on your own data

rows = []
for pdf in sorted(Path("resumes").glob("*.pdf")):
    text = pdf_text(str(pdf))
    words = len(text.split())

    if words == 0:
        rows.append({"file": pdf.name, "status": "manual_check", "note": "no extractable text (scanned?)"})
        continue
    if words < MIN_WORDS:
        rows.append({"file": pdf.name, "status": "not_scored", "note": f"only {words} words"})
        continue

    result = detect_ai(text)
    p = result["ai_probability"]
    # Keep the passages that scored highest so reviewers know where to look
    top = sorted(result.get("segments", []), key=lambda s: s["ai_prob"], reverse=True)[:2]
    rows.append({
        "file": pdf.name,
        "status": "review" if p >= REVIEW_THRESHOLD else "ok",
        "ai_probability": p,
        "note": " | ".join(s["text"][:120] for s in top),
    })
    time.sleep(0.5)  # be gentle with rate limits

with open("review_queue.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["file", "status", "ai_probability", "note"])
    writer.writeheader()
    writer.writerows(rows)

print(f"Scanned {len(rows)} resumes → review_queue.csv")

The output gives recruiters a list of files to look at more closely, with the passages that drove the score. It doesn't reject anyone.

Guardrails every hiring integration needs

1. No automatic rejection. Treat the score like a "look closer" flag. Combine it with structured interviews, work samples and reference checks.

2. Watch for bias. Detectors have been shown to flag non-native English writing more often (Liang et al., Stanford, 2023). In a global hiring pipeline, that can turn into discrimination against certain groups of candidates. Monitor flag rates across groups where you lawfully can, and adjust thresholds.

3. Check the law where you hire. Automated tools in hiring are regulated in a growing number of places. For example, New York City's Local Law 144 requires bias audits and notices for automated employment decision tools, and the EU AI Act treats AI systems used in recruitment as high-risk. Talk to your legal team before you ship.

4. Be transparent with candidates. Say in the job posting or privacy notice that application materials may be checked by automated tools, and give a way to ask for human review.

5. Verify claims, not prose. The strongest defence against fabricated experience is still old-fashioned: ask the candidate to talk through a project, run a short live exercise and check references.

Wrapping up

AI detection can help recruiters spend their limited time where it matters, but only if it's built as a prioritisation tool with human decisions at the end. The code is the easy part. The guardrails are what make it fair.

ProofAI has a dedicated AI resume checker for recruiters, and the API if you're building it into an ATS.

If you work on hiring tools: how is your team handling AI-written applications right now? We'd love to compare notes in the comments. 👇

---

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team. This post isn't legal advice.