An AI screening agent I was testing read a profile that listed Java, JavaScript, TypeScript, Python, and C++ in its skills section, and summarized the candidate as a "versatile full-stack polyglot." The person behind the profile was a backend Java engineer who had spent seven years on one payments platform. The model wasn't lying. It was averaging.
I build AI career tools for a living, which means I spend a lot of time watching language models parse resumes, job postings, and profiles. The pattern is consistent: when your profile is ambiguous, the model doesn't leave a blank. It fills the gap with the statistically most likely answer. That's how a Django developer gets summarized as "experienced with Flask and FastAPI," and how "cloud experience" quietly becomes "AWS."
More companies are putting an AI agent in front of the human recruiter, and that agent's summary is often the only version of you a hiring manager reads. LinkedIn profile optimization used to mean cramming keywords for a search index. Now it means writing so a language model can't misread you.
Why the model invents skills you never claimed
Large language models predict from co-occurrence. Skills that usually appear together in their training data get inferred together, whether or not you have them. List React with nothing else, and a summarizer will happily attribute "modern frontend ecosystem experience, likely Next.js and Redux." Say "built microservices" without naming a language, and you'll get whatever stack is most common next to that phrase, which is usually not yours.
The hallucination happens exactly where you leave a gap. A vague headline, an unattributed bullet, a skill with no supporting evidence anywhere in your experience section. The model has to produce a confident summary either way, so it produces a confident guess.
This cuts both ways. The same mechanism that invents skills also erases them. If your Rust work lives only in a skills tag and never appears in a single experience bullet, a summarizer will often drop it entirely, because unsupported claims get compressed out. The skills you never mention in context are the first ones to disappear.
Keyword stuffing worked on old ATS. It backfires on LLMs
Classic applicant tracking systems (ATS) did exact-match filtering. If the posting said "Kubernetes" and your profile said "Kubernetes," you passed. That created a whole generation of advice: list everything, repeat everything, pad the skills section to 50 entries.
An LLM-based screener reads the whole profile as one document and reasons about it. Feed it a wall of 50 skills and it can't rank your depth in any of them, so the summary comes out as "broad but unclear specialization." That's a polite way of saying generic, and generic loses to the candidate whose profile reads as "Go and Postgres, payments infrastructure, eight years."
There's a second failure mode I see in testing: contradiction. When a skill sits in your list but appears nowhere in your work history, models increasingly flag it. A summary that includes "lists machine learning, though no ML work is evident in the experience section" is worse than not listing ML at all. The stuffed profile now reads as padded, and the model says so out loud.
Write claim-evidence pairs, not skill soup
The fix is a rule I apply to every bullet: name the stack inside the sentence where the work happened. A model can only attribute a skill it can locate.
Compare these two versions of the same work:
- Weak: "Improved API performance and reduced infrastructure costs."
- Strong: "Cut p95 API latency from 800ms to 120ms by moving session storage from Postgres to Redis, then dropped compute spend by consolidating three ECS services into one."
The first bullet gives a parser nothing to anchor. The second one lets it extract Postgres, Redis, ECS, a performance result, and a cost result, all attributed to you specifically. When the screening agent writes its summary, your actual stack shows up because it had somewhere to point.
Then prune the skills section until it matches. My working test: would you take an interview question on it today? If not, cut it. Fifteen skills you can defend beat fifty you can't, and LinkedIn lets you pin your top skills, so put the three that define your target role first. Order is signal too.
The same rules apply to your resume, since the AI reading it is often the same one reading your profile. I build Roleframe, so I'm biased, but the reason I know these failure modes so well is that our tailoring pipeline parses job postings and resumes all day, and the resumes that map cleanly to a posting's requirements are always the ones where every skill claim sits next to its evidence.
Your headline and the first two lines of About do most of the work
Parsers weight position. Your headline and the opening of your About section get read first and anchor everything that follows, the same way a recruiter's seven-second skim does.
A headline like "Passionate technologist | Lifelong learner | Building the future" gives a model zero extractable facts, so it borrows facts from elsewhere and guesses the rest. Use the boring, dense formula instead: role, specialization, primary stack. "Senior Backend Engineer | Payments infrastructure | Go, Postgres, Kafka." Unglamorous, and unmistakable.
Open your About section with the sentence you want quoted in the AI's summary, because it often will be, nearly verbatim: "Backend engineer with 8 years building payment systems in Go and Postgres, currently focused on ledger correctness at scale." After that anchor is set, you can write like a human for the rest of the section.
One more cut: kill "familiar with" and "exposure to" lists. Models routinely drop the hedge and keep the skill, which turns "exposure to Kubernetes" into "Kubernetes experience" in the summary. If that inflation would hurt you in a technical screen, don't feed it to the parser. If the skill is real, state it plainly and back it with a bullet.
Test your profile the way a screener reads it
You don't have to guess how a model reads you. Copy your full profile text, paste it into any chatbot, and run this:
You are a technical recruiter using AI to screen candidates.
Based only on the text below, summarize this candidate in five bullets:
their seniority, their specialization, their primary tech stack,
their strongest evidence of impact, and anything ambiguous or
unsupported. Do not infer skills that are not stated.
[paste profile]
Then audit the output. Every skill in the summary that you don't actually have marks a spot where your profile is vague enough to invite a guess. Every real skill that's missing marks a claim with no evidence attached. Fix the source text, run it again, and repeat until the summary describes the engineer you'd defend in an interview. Even with the "do not infer" instruction, models drift, and where yours drifts is exactly where a screening agent will too.
Thirty minutes of this loop does more than any keyword checklist, because you're testing against the actual reader.
The profile that survives is the specific one
AI screening punishes exactly what old ATS advice rewarded. Vagueness used to be safe padding. Now it's an open invitation for a model to write your summary for you, with a stack you've never touched.
So make yourself boring to a parser: a dense headline, an anchor sentence up top, stacks named inside the bullets where the work happened, and a skills list you could interview on tomorrow. Then run the paste-and-summarize test tonight. If the model gets you wrong, a screening agent already has.
Top comments (0)