# How Job Fit Evaluation Scoring Works Against Candidate Profiles in AI-Job-Search

> Discover how AI-Job-Search scores job fit against candidate profiles. Explore weighted evaluation for technical skills, experience, culture, and career goals to get tailored recommendations.

- Repository: [Mads Lorentzen/ai-job-search](https://github.com/MadsLorentzen/ai-job-search)
- Tags: how-to-guide
- Published: 2026-07-26

---

**The AI-Job-Search repository implements a weighted, multi-dimensional framework that converts structured candidate profiles and job postings into a quantitative 0-100 fit score, first applying a hard eligibility filter for work authorization before calculating technical alignment, experience relevance, cultural fit, and career trajectory to generate tiered application recommendations.**

The MadsLorentzen/ai-job-search project provides a rigorous **job fit evaluation scoring** system designed to automate candidate-job matching through objective, reproducible criteria. Defined in the Markdown specification at [`.claude/skills/job-application-assistant/04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/skills/job-application-assistant/04-job-evaluation.md), this framework executes via LLM-powered agents when users invoke evaluation commands, transforming raw profile data into strategic application decisions.

## The Job Evaluation Framework Architecture

At the core of the system lies a specification file that dictates how the agent processes incoming job postings against stored candidate profiles. According to the source code in [`04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/04-job-evaluation.md), the evaluation occurs in distinct sequential phases: an initial eligibility gate followed by quantitative dimensional scoring. The framework outputs a structured table containing individual dimension scores, an overall weighted average, a categorical verdict, and actionable next steps for cover letter tailoring or interview preparation.

## Step 1: The Eligibility Gate (Hard Filter)

Before any numeric calculation begins, the framework enforces a mandatory **eligibility gate** that examines citizenship and work permit requirements from the job posting. As implemented in the specification (lines 33-71), if the candidate fails to meet these legal prerequisites—such as lacking required residency status or work authorization—the role receives an immediate rejection with no score generated. This gate prevents the system from drafting applications to positions where the candidate cannot legally work, saving time and avoiding disqualification on procedural grounds.

## Step 2: The Five Scoring Dimensions

For postings that clear the eligibility gate, the framework evaluates five distinct dimensions. Four dimensions receive numeric scores on a 0-100 scale, while location serves as a binary pass/fail flag. The specific weights and measurements defined in lines 83-91 of the specification distribute importance across the following categories:

- **Technical Skills Match (30%):** Measures the overlap between the job's required technical stack and the candidate's primary and secondary skills listed in [`01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/01-candidate-profile.md).

- **Experience Match (25%):** Evaluates alignment between the candidate's work history domains and the role's specific responsibilities and industry context.

- **Behavioral / Culture Fit (15%):** Assesses compatibility between the candidate's behavioral traits—defined in [`02-behavioral-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/02-behavioral-profile.md)—and the company's stated cultural values or team dynamics.

- **Career Alignment & Motivation (30%):** Quantifies how effectively the position advances the candidate's long-term career goals, learning objectives, and professional energizers.

- **Location & Logistics (Pass/Fail):** Determines feasibility based on relocation requirements, commute practicality, and travel expectations without contributing to the numeric average.

## Step 3: Weighted Score Calculation and Thresholds

The **job fit evaluation scoring** algorithm computes a weighted average using the formula specified in the framework:

```

overall = (tech × 0.30) + (experience × 0.25) + (behavioural × 0.15) + (career × 0.30)

```

Location status remains separate from this calculation, recorded only as a PASS or FAIL flag. The resulting overall score maps to specific verdict thresholds defined in lines 75-79 of the specification:

- **75-100:** Strong Fit — "Definitely apply, tailor everything."
- **60-74:** Good Fit — "Apply, address gaps in the cover letter."
- **45-59:** Moderate Fit — "Consider carefully; discuss with the user."
- **30-44:** Weak Fit — "Probably skip unless strategic."
- **<30:** Poor Fit — "Skip."

## Implementation Example: Computing Fit Scores in Python

Developers extending the AI-Job-Search system can replicate the scoring logic using the weights defined in the specification. Below is a Python implementation that calculates the weighted overall score:

```python
def weighted_overall(scores):
    """
    Calculate the weighted overall fit score.
    `scores` dict must contain:
    - tech, experience, behavioural, career (0-100 each)
    """
    weights = {
        "tech": 0.30,
        "experience": 0.25,
        "behavioural": 0.15,
        "career": 0.30,
    }
    overall = sum(scores[k] * w for k, w in weights.items())
    return round(overall, 1)


# Example usage

candidate_scores = {
    "tech": 78,
    "experience": 65,
    "behavioural": 70,
    "career": 82,
}
print("Overall fit:", weighted_overall(candidate_scores))

# → Overall fit: 73.9

```

To derive the categorical verdict from the numeric score, implement the threshold logic as follows:

```python
def verdict(overall):
    if overall >= 75:
        return "Strong Fit"
    if overall >= 60:
        return "Good Fit"
    if overall >= 45:
        return "Moderate Fit"
    if overall >= 30:
        return "Weak Fit"
    return "Poor Fit"


# Continuing the previous example

print("Verdict:", verdict(weighted_overall(candidate_scores)))

# → Verdict: Good Fit

```

## Integration With Candidate Profiles and Job Scrapers

The **job fit evaluation scoring** system operates as the central processing layer between data collection and application generation. During the `/setup` phase, the system collects candidate attributes through [`01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/01-candidate-profile.md) (skills, career goals) and [`02-behavioral-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/02-behavioral-profile.md) (personality traits, work preferences). Concurrently, scraper agents located under `.agents/skills/` (e.g., LinkedIn, Indeed parsers) extract structured job posting data.

When the `/evaluate` command executes, the LLM receives a prompt embedding the eligibility criteria and scoring dimensions from [`04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/04-job-evaluation.md), then returns a populated evaluation table (lines 34-44) containing strengths, gaps, and recommendations. Downstream commands such as cover-letter drafting read this table to determine which qualifications to emphasize and which deficiencies to address proactively. The [`tools/check_upstream_updates.py`](https://github.com/MadsLorentzen/ai-job-search/blob/main/tools/check_upstream_updates.py) script (line 27) references this specification to ensure scoring logic remains synchronized across repository updates.

## Summary

- The framework applies a **hard eligibility filter** for work authorization before scoring begins, immediately rejecting ineligible postings.
- Four dimensions (**Technical Skills**, **Experience**, **Behavioral Fit**, **Career Alignment**) receive weighted scores (30%, 25%, 15%, 30%) on a 0-100 scale.
- **Location and logistics** operate as a binary pass/fail check excluded from the numeric average.
- Overall scores map to five verdict tiers (**Strong** to **Poor Fit**) that drive specific application strategies.
- The specification at [`.claude/skills/job-application-assistant/04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/skills/job-application-assistant/04-job-evaluation.md) serves as the single source of truth consumed by LLM agents and validation tools.

## Frequently Asked Questions

### How does the system handle candidates who don't meet citizenship requirements?

The eligibility gate defined in the job evaluation specification performs an immediate hard filter on citizenship and work permit requirements. If the candidate lacks the necessary legal authorization specified in the job posting, the system rejects the application instantly without calculating a fit score, ensuring no resources are spent on legally impossible applications.

### Can the scoring weights be customized for different roles or industries?

The current implementation in [`04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/04-job-evaluation.md) specifies fixed weights (30% Technical, 25% Experience, 15% Behavioral, 30% Career) hardcoded into the LLM prompt. While the Python implementation examples demonstrate how weights function mathematically, modifying the actual evaluation behavior requires editing the Markdown specification file to adjust the dimensional importance for specific role types.

### What data sources feed into the job fit evaluation scoring algorithm?

The algorithm consumes structured data from three primary sources: the candidate's profile defined in [`01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/01-candidate-profile.md) (skills, career goals), behavioral traits from [`02-behavioral-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/02-behavioral-profile.md), and parsed job posting data from web scrapers under `.agents/skills/`. The [`tools/check_upstream_updates.py`](https://github.com/MadsLorentzen/ai-job-search/blob/main/tools/check_upstream_updates.py) utility ensures these data schemas remain compatible with the evaluation logic.

### How does the output format guide downstream application drafting?

The evaluation produces a structured table (specified in lines 34-44 of [`04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/04-job-evaluation.md)) containing dimension scores, overall fit, verdict classification, and specific sections for strengths and gaps. Cover letter generation agents parse this table to strategically highlight high-scoring dimensions while proactively addressing identified weaknesses, ensuring tailored rather than generic applications.