AI Job Search Automation, Open Source: Inside the 62,000-Star Framework That Applies to Jobs for You

AI job search automation open source projects are having their breakout moment, and the clearest proof is a single repository: MadsLorentzen/ai-job-search. With more than 62,000 stars and 19,000 forks, it sits among the most starred agent projects on GitHub — and it is unlike almost everything else in the trending charts. It was not built to demo an API. It was built to get its creator hired. It worked.

Its author, Mads Lorentzen, is a geophysicist whose position was cut in late 2025. He turned Claude Code into a full-stack job application assistant — one that evaluates postings, tailors CVs, writes cover letters and prepares you for interviews — then ran his own job search through it: 69 tailored applications, 20 first interviews, one signed contract, and a start date as an AI engineer in June 2026. He was upfront with every employer about using it, and instead of counting against him, it usually sparked a genuine technical conversation.

In this deep dive, we unpack what the framework is, what it can actually do, how it works under the hood, what it costs to run, and — the part that matters most if you build software or hire people — what the hiring-automation wave means for employers and job seekers alike. If you like keeping a finger on the pulse of agent tooling, our AI tools directory tracks launches like this one as they land.

AI job search automation, open source: why this repo is exploding

Job applications are close to the perfect agent workload: structured, repetitive, high stakes, and deeply disliked by the humans doing them. A single tailored application can eat an evening. Sixty-nine of them can eat a quarter. The repository’s tagline — “The job search that runs on your machine” — promises to give that time back, and the star count says the promise landed. It is also riding a daily-trending badge from Trendshift and an active community that keeps adapting the tooling to new markets.

There is a deeper reason, though. Most agent projects on the trending page optimise a developer workflow that only developers care about. This one touches a problem everyone understands: the job hunt. Lorentzen’s funnel numbers — 69 applications, 20 first interviews, roughly a 29% first-interview rate — are the kind of concrete proof most automation projects never publish. When a tool’s author can say “it got me hired” with receipts, people pay attention.

The timing matters too. Through 2026, coding agents went from impressive demos to daily tools, and the playbook is spilling into every other white-collar workflow. Hiring is a natural next beachhead: employers already screen with AI, so candidates levelling the playing field with their own agents is less a surprise than an inevitability.

What AI Job Search actually is

Strip away the star count and AI Job Search is not an app with a dashboard. It is a structured workflow — a set of agent skills plus small CLI tools — that turns Claude Code into a full-stack job application assistant. You run slash commands inside Claude Code, and the framework handles the unglamorous pipeline: self-profiling, fit evaluation, and a drafter-reviewer application loop.

The design is deliberately language- and country-agnostic at its core. The job-portal search skills ship built for the Danish market — Jobindex, Jobnet, Akademikernes Jobbank and friends — because that is where the author lives. But the pattern is designed to be swapped for your local boards, and community forks are already adapting it; the project’s discussion board maintains a portal index for exactly this purpose. The MIT licence means you can fork it and own it outright.

What it can do

The workflow is driven by a small vocabulary of slash commands. Here is what each one does, straight from the project’s documentation:

• /setup — build your profile. Three onboarding paths: point it at a documents/ folder of CVs and certificates, paste a single CV, or walk through an interview. It captures your employment history, a Languages table with your working level in each language, deal-breakers (“no on-call”, minimum salary expectations, parental-leave terms) and free-form preferences. The README stresses the one thing that determines output quality: profile depth. A thin profile produces generic applications; a detailed one — projects, tools, measurable achievements, what energised you and what drained you — enables genuinely tailored results.
• /scrape — search job portals. Portal skills search supported boards and present matches with fit ratings. The skills themselves are small Bun CLIs that live under .agents/skills/; the installer discovers them automatically rather than maintaining a hardcoded list, so a portal you add is picked up on a fresh clone.
• /apply <url> — evaluate and draft. The heart of the framework. It evaluates a posting against your profile with a structured rubric, applies a Language Gate (hard-rejects a posting that requires a language you have not declared; flags — rather than silently dropping — borderline cases like a strict “fluent” bar against your own B1/B2, leaving the judgement to you), then drafts a tailored CV and cover letter. Output compiles to PDF via LaTeX — lualatex for the CV, xelatex for the cover letter, since the cover template needs fontspec.
• Drafter-reviewer pipeline. Drafts are not final. A reviewer agent critiques the application, it gets revised, and only then is it final output. This two-pass loop is the difference between “AI slop” and something you would actually send.
• ATS parseability check. The /apply step can check that the generated PDF parses cleanly for applicant tracking systems, using pypdf — no Poppler required — with Poppler’s pdftotext as a fallback and a visual keyword review as a last resort. An elegant touch: the tool that helps you beat the screening robots also makes sure the screening robots can read you.
• /interview — interview prep. Turns your profile and the posting into preparation material.
• /rank, /add-portal, /add-template, /reset. Rank postings, register a new job board, register any CV or cover-letter toolchain that compiles to PDF from the command line (LaTeX or otherwise), and wipe profile data — /reset shows exactly what will be deleted and makes you type RESET to confirm. Nothing is deleted until you do.
• Salary benchmarking. Works with whatever salary data you feed it — union statistics, Glassdoor exports, personal research — and is simply skipped if you provide none.

How it works under the hood

Technically, the framework is a showcase of the agent-skills pattern done properly. The core workflow — self-profiling, fit evaluation, the drafter-reviewer loop — is encoded as skill files that any capable agent can follow, and the portal CLIs are TypeScript packages installed with Bun. The project even ships an AGENTS.md so the whole workflow adapts to other agent tools — Codex, Gemini CLI and similar — out of the box for the portal search skills, with community forks adapting the rest.

One design decision deserves attention because it is a security decision wearing a UX costume: the copy step for third-party portal skills is manual on purpose. Installed portal skills run pre-approved on your machine — .claude/settings.json allowlists them — against your most sensitive career data. So before you borrow a skill from another fork, the project tells you to read all of its code, verify its network calls only hit the board it claims to search, check that package.json has no dependencies and no lifecycle scripts, and run its tests offline. An installer that fetched portal skills for you would skip the one check that matters: you, reading the code first. That is the kind of judgement call that separates serious agent infrastructure from demo-ware.

Upstream moves fast, and the project has a grown-up answer for staying current without breaking your personalised setup: update to tagged releases rather than raw master, preview exactly which of your personalised files an update touches with check_upstream_updates.py, and sort the commits you are behind into “worth reviewing” versus “probably skip” with upstream_triage.py. It is the kind of maintenance tooling most open source projects never bother to build.

Getting started

If you want to run your own job search on your machine, here is the honest path:

1. Decide fork vs private repo first. A GitHub fork of a public repo is always public, and /setup writes your name, contact details, employment history and salary expectations into tracked files. If this copy is for your own job search rather than contributing changes back, use a private repository with the project as upstream instead — the two-minute recipe is in the project’s SETUP.md, and every update workflow works identically. Only fork publicly if you intend to contribute.
2. Clone and install the portal CLIs. gh repo fork MadsLorentzen/ai-job-search --clone, then cd ai-job-search and run python3 tools/install_portal_clis.py (it runs bun install in every portal CLI; --dry-run shows what it would do first).
3. Set up your profile. Launch claude and run /setup. Pick whichever onboarding path matches what you have — a folder of documents, a single CV, or the guided interview. Invest real time here: describe what you actually did in each role, with projects, tools and measurable outcomes, not just titles. This is the single biggest lever on output quality.
4. Run the loop. /scrape to search portals, review matches with their fit ratings, /apply <url> on the ones worth your time, /interview to prepare. Review every draft the reviewer agent produces — the pipeline is assistive, not autonomous.
5. Stay current via releases. Update to tagged releases, preview the impact with check_upstream_updates.py, and triage with upstream_triage.py before merging.

Prerequisites are real and worth knowing before you start: Claude Code (the CLI — note it has no free tier, so budget for a Claude Pro/Max/Team subscription or pay-per-token API credits), Python 3.10+, Bun, and a LaTeX distribution such as TeX Live, MacTeX, TinyTeX or MiKTeX. The LaTeX install is the fiddliest part for most people — the CV needs lualatex, the cover letter needs xelatex, and minimal installs like TinyTeX or BasicTeX need extra packages from the setup guide. One honest gotcha from the docs: pdflatex often fails on modern MiKTeX installs with fontawesome5 font-expansion errors, so follow the recommended compilers.

From our experience: where this fits — and where it does not

We build AI integration and automation systems for a living, so frameworks like this are our home turf. What stands out about AI Job Search is that it is automation done right: local-first, review-gated, and honest about its inputs. The drafter-reviewer loop is the pattern we recommend to clients for any agent workflow that produces externally visible output — a second pass that critiques before anything ships catches the confident nonsense that single-pass agents love to generate.

The cost reality. The repo is free (MIT), but running it is not zero. Claude Code needs a paid subscription or API credits, and a serious job search — scraping, dozens of fit evaluations, draft-revise cycles — will burn through tokens. Lorentzen himself notes that pay-per-token API credits are usually cheaper for occasional use. Treat the token budget like a campaign budget: it is still an order of magnitude cheaper than the evenings you get back, but do not walk in expecting free.

For employers, the message is blunt: your candidates are already doing this. Polished, tailored, ATS-parseable applications are about to become the baseline, not the exception. Do not respond by building defences against good formatting — respond by making your screening test real capability. Lorentzen’s own experience is instructive: he disclosed his use of the framework to every employer and it sparked genuine technical conversations instead of suspicion. The interview process, not the application format, is where hiring signal lives. If your pipeline cannot distinguish a strong candidate with an AI assistant from a weak candidate with one, that is a pipeline problem, not a tools problem.

When not to use it. Do not turn this into a spray-and-pray machine. The framework is assistive by design — it drafts, you review, you send — and fire-and-forget mass applying will burn you: portal account flags, a reputation for low-effort applications, and cover letters that carry the unmistakable texture of machine output. The framework’s own design philosophy is quality over volume: fit evaluation first, reviewer agent second. Trust that design.

The underrated feature. Do not sleep on the latent-opportunity mode: because the framework analyses your full history — not just job titles, but the actual work you did — it can surface career paths you had not considered. Transferable skills mapping to unexpected industries is exactly the kind of reframing humans are bad at for themselves. For career changers, that discovery step may be worth more than all the cover letters combined.

A responsible-use note

Two cautions from the project itself, both worth repeating. First, privacy: your profile is your career in files. A public fork exposes it. Use a private repo with the project set as upstream, as the setup guide describes. Second, supply-chain hygiene: third-party portal skills run pre-approved against your most sensitive data, so read their code before installing — no dependencies, no lifecycle scripts, no reads or writes outside their own folder, tests passing offline. The project also explicitly warns that it has no affiliated cryptocurrency, token, or paid sponsorship programme — anything claiming otherwise is a scam. In a repo with 62,000 stars, that warning is doing real work.

Frequently asked questions

Is AI Job Search free to use?

The repository is MIT-licensed and free to fork. Running it is not free, because it is built on Claude Code, which has no free tier — you need a Claude Pro/Max/Team subscription or pay-per-token API credits. The author notes API credits are usually cheaper for occasional use.

Which job boards does it support?

Out of the box, the portal search skills target the Danish market — Jobindex, Jobnet, Akademikernes Jobbank and similar. The core workflow is language- and country-agnostic, and the portal pattern is designed to be swapped: you can add a board with /add-portal, register any CV toolchain with /add-template, or borrow a community-built portal skill from another fork via the project’s portal index.

Does it submit job applications automatically?

No — and that is a feature. It evaluates postings, drafts tailored CVs and cover letters through a drafter-reviewer loop, and prepares you for interviews, but you review and send. The design philosophy is quality over volume, and mass auto-applying would undermine the fit evaluation that makes the output good.

Is my personal data safe?

It runs entirely on your machine, which is the right architecture for something holding your employment history and salary expectations. The one trap: a GitHub fork of a public repo is always public, and your profile lives in tracked files. Use a private repository with the project as your upstream remote instead.

Can it work outside Denmark?

Yes. Self-profiling, fit evaluation and the drafter-reviewer pipeline are language- and country-agnostic. Only the portal search skills are market-specific, and they are swappable — community forks are already adapting the framework to other job boards, coordinated through the project’s portal index.

The hiring-automation wave is not coming; it is here, it has 62,000 stars, and it got its author hired. Whether you are a candidate who wants their evenings back or an employer rethinking how you screen, the winning move is the same one this project models: automate the repetitive parts, keep a human in the review loop, and let the interview do the talking. If your team wants to put agent workflows like this to work inside your business — screening, drafting, triage, the unglamorous middle of any operation — talk to us. This is what we build.