JobPilot

JobPilot helps job seekers find the roles worth their time, explains verified strengths and gaps, and turns each match into an auditable application strategy.

Comment

Inspiration

Job searching often creates the wrong kind of work. Candidates spend hours opening listings, comparing requirements, guessing whether a match score is meaningful, and rewriting the same information for every application.

Most matching tools provide a number without showing enough evidence behind it. A high score can feel encouraging, but it does not answer the questions that matter: Which requirements do I actually meet? What is missing? Is this role worth my time? What should I emphasize if I apply?

I built JobPilot to make those decisions faster, clearer, and more accountable.

What it does

JobPilot helps job seekers identify the roles worth pursuing and understand why.

For each role, it provides:

  • verified strengths supported by evidence
  • attention areas and meaningful gaps
  • required versus preferred qualification analysis
  • a deterministic AI Fit score
  • an application strategy based on the candidate’s actual evidence
  • an independently reproducible Score Receipt
  • a private application tracker
  • a Trust Lab explaining the system’s boundaries and limitations

JobPilot never auto-applies. The candidate stays in control of every decision and every external application.

How it works

JobPilot separates semantic analysis from final scoring.

Gemma 4 12B is the primary local semantic model. It analyzes the relationship between a candidate profile and a job description, identifying evidence, requirements, strengths, and gaps.

Deterministic AI Fit V2.2 then calculates every final score. The language model does not directly assign the Fit Score.

Each result also produces a Score Receipt. The receipt records the scoring inputs and can independently reproduce the result. A valid receipt returns FULLY_REPRODUCED, while a modified receipt is rejected as INVALID.

The public demo uses synthetic jobs and candidate profiles so judges can explore the complete workflow without uploading private information.

How Codex was used

Codex was the primary development and release environment throughout the project.

I used Codex to:

  • design and implement the product workflow
  • debug scoring and evidence-quality problems
  • reproduce UI and CSS defects
  • build the Score Receipt verification system
  • create regression tests
  • validate privacy boundaries
  • repair responsive layouts
  • audit public deployment metadata
  • review submission claims against implementation evidence
  • prepare the final Vercel and video release

Codex was especially useful because it could move between product code, tests, browser behavior, release artifacts, and documentation while keeping the final claims grounded in reproducible evidence.

How GPT-5.6 was used

GPT-5.6 contributed prepared application strategy and critique through Codex.

Its role is intentionally separated from scoring. GPT-5.6 does not calculate AI Fit, change the deterministic score, or make hiring decisions.

This separation allows JobPilot to benefit from stronger strategic reasoning while preserving a reproducible and auditable scoring layer.

The public product makes zero OpenAI API requests at runtime, and its OpenAI API runtime cost is $0.

Technical architecture

JobPilot is built around four distinct layers:

  1. Local semantic analysis
    Gemma 4 12B identifies requirements, candidate evidence, strengths, and gaps.

  2. Deterministic scoring
    AI Fit V2.2 converts verified evidence into the final score.

  3. Independent verification
    Score Receipts reproduce the scoring result and detect tampering.

  4. Prepared strategy and critique
    GPT-5.6 contributes application guidance through Codex without controlling the score.

The public application is deployed on Vercel and uses cached synthetic analyses. Private resume processing is designed to remain local.

Challenges

The hardest challenge was not generating more AI output. It was deciding what the AI should and should not control.

Early versions placed too much emphasis on the score. I redesigned the experience around evidence first: Strong Evidence, Attention Areas, and Application Strategy.

Another challenge was reproducibility. A visually convincing result is not enough if the score cannot be independently checked. This led to the Score Receipt system and deterministic scoring boundary.

I also had to maintain privacy while still creating a public demo. The submitted version contains no participant records, private resumes, API credentials, or raw research data.

Finally, the release required careful validation across clean clones, Webpack production builds, responsive layouts, public deployment metadata, video artifacts, and submission documentation.

Accomplishments

I am proud that JobPilot now combines useful AI reasoning with explicit trust boundaries.

The final release includes:

  • deterministic and reproducible Fit Scores
  • evidence-first job analysis
  • valid and tamper-detecting Score Receipts
  • local-first semantic analysis
  • prepared GPT-5.6 application strategy
  • private tracking without automatic applications
  • responsive public workflows
  • 132 passing tests
  • 0 lint errors and 0 warnings
  • 0 production dependency vulnerabilities

The final public release was also validated through clean-clone builds, responsive browser checks, receipt reproduction, privacy scans, and logged-out public testing.

What I learned

The biggest lesson was that trustworthy AI is not created by adding more explanations after a model produces an answer.

Trust has to be designed into the architecture.

The system needs clear ownership of each decision: the semantic model identifies evidence, deterministic code calculates the score, the receipt verifies the calculation, and the user decides whether to apply.

I also learned that a smaller, directional usability study can still be valuable when its limitations are stated clearly and the claims remain narrow.

Directional usability evidence

I conducted a moderated directional usability study with five participants and ten human task rows.

Observed results:

  • median decision time decreased from 39 seconds to 18 seconds
  • factual accuracy increased from 75% to 100%
  • mean confidence increased from 3.8 to 6.0 out of 7
  • mean clarity increased from 3.6 to 6.2 out of 7

These results describe this small moderated study only. They are not presented as proof of causality or as evidence of improved hiring outcomes.

Limitations

All participants completed the traditional condition first and JobPilot second. Different roles prevented same-role carryover, but practice or order effects may contribute to the observed difference.

The study included only five participants, so the findings are directional and not representative of the broader job-seeking population.

AI Fit is not a hiring probability, and JobPilot cannot know how an employer will evaluate a candidate.

The public demo uses synthetic data and cached analyses. JobPilot does not submit applications, contact employers, or automatically move an application into an Applied state.

What is next

The next step is to evaluate JobPilot with a larger and properly randomized study.

I also want to expand local semantic-model support, improve evidence extraction across more resume formats, add user-controlled comparison tools, and continue strengthening receipt-based verification.

The long-term goal is a job-search assistant that helps people spend less time decoding listings and more time pursuing opportunities supported by real evidence.

Links

Live demo:
https://job-pilot-build-week.vercel.app

GitHub repository:
https://github.com/yeon971105/JobPilot-BuildWeek

Demo video:
https://youtu.be/TPOwoSZSRp0

Built With

Share this project:

Updates