‘Entry-Level’ Gatekeepers: Auditing Job Descriptions With textstat

Some “entry-level” job descriptions ask candidates to “leverage cross-functional paradigms to optimize synergistic outcomes.” When postings are stuffed with dense corporate jargon, they do more than confuse readers — they discourage capable, qualified applicants. Because accessibility is the first step toward inclusivity, auditing job descriptions for clear tone is worthwhile. This guide shows how to use Python and the free, open-source textstat library to build a script that flags “gatekeeping language” before a posting goes live.

The key metric: the Gunning Fog Index

The Gunning Fog Index estimates how many years of formal education a reader would need to understand a passage on the first read. It is calculated from two factors: average sentence length and the percentage of complex words, generally those with three or more syllables. Because corporate jargon leans heavily on multi-syllable words such as “operationalize” and “functionality,” the Fog score climbs quickly when text is too dense for the audience it is meant to attract. A lower score means greater clarity — exactly what an entry-level role calls for.

Building the auditor

First, install textstat:

pip install textstat

The core logic is a small, reusable function: compute the Gunning Fog score for the input text, then map it to one of three verdicts, like a traffic light.

import textstat

def audit_job_description(text: str) -> dict:
    fog_score = textstat.gunning_fog(text)

    if fog_score < 10:
        verdict = "Accessible - ideal for entry-level roles"
    elif fog_score <= 14:
        verdict = "Slightly complex - consider simplifying"
    else:
        verdict = "Highly complex - needs substantial rework"

    return {"fog_score": round(fog_score, 1), "verdict": verdict}

As a rule of thumb, a Gunning Fog score below 10 is accessible and well suited to entry-level descriptions, 10 to 14 is slightly complex, and anything above 14 is highly complex and likely needs rewriting. Handling the text input and output for a script like this builds on basic file handling in Python.

Testing it on two examples

The next step compares a jargon-heavy posting against a plain-language one:

# Example 1: a "gatekeeper" job description
complex_jd = """
The successful candidate will leverage cross-functional paradigms to optimize
synergistic deliverables. You will operationalize key performance indicators and
facilitate continuous improvement methodologies to maximize return on investment
and institutionalize core competencies across the organizational ecosystem.
"""

# Example 2: an "inclusive" job description
inclusive_jd = """
We are looking for a team player to help us grow our marketing channels. You will
work closely with different teams to launch campaigns, track how well they do, and
find new ways to improve. Your goal is to help us reach more people.
"""

for label, jd in [("Complex", complex_jd), ("Inclusive", inclusive_jd)]:
    print(label, audit_job_description(jd))

The jargon-laden first example scores well above the entry-level threshold, while the second lands comfortably in the accessible range — confirming with a number what intuition already suggested.

Why it matters

A job description is the front door to a company, and excessive business jargon acts like a bouncer in exactly the situations where openness matters most: entry-level roles, where the goal is to widen rather than narrow the applicant pool. A lightweight, automated readability check turns an abstract goal — writing clearly — into a concrete, repeatable test that can run before any posting is published.