AI Job Search Framework: How to Automate 90% of Your Job Applications With Claude Code (13,800+ GitHub Stars)

The Job Search Problem (And Why AI Changes Everything)

Let's be honest: job hunting is exhausting. For every position you apply to, you're looking at:

• Reading the job description (5 minutes)
• Evaluating if you're a good fit (10 minutes)
• Tailoring your CV to highlight relevant experience (30-60 minutes)
• Writing a cover letter that doesn't sound generic (30-60 minutes)
• Researching the company for interview prep (20 minutes)

That's 2-3 hours per application. If you're applying to 20 jobs, you're looking at 40-60 hours of work before you even get an interview.

What if you could compress that to 15 minutes per application — and get better results because the AI actually reads every word of the job posting and matches it against your entire career history?

That's exactly what ai-job-search does. And with 13,800+ GitHub stars (and 5,000+ stars in a single day), developers are clearly hungry for this solution.

What Is ai-job-search?

ai-job-search is an open-source framework built on Claude Code that turns AI into your full-stack job application assistant. It's not a SaaS product or a Chrome extension — it's a structured workflow that lives in your terminal and uses Claude's reasoning capabilities to handle the entire application process.

Here's what it does:

• Profile building: Imports your CV, LinkedIn, diplomas, and past applications to create a comprehensive profile
• Job search: Scrapes job portals (Jobindex, Jobnet, LinkedIn, etc.) for positions matching your skills
• Fit evaluation: Scores each job on 5 dimensions: skills match, experience alignment, culture fit, location, and career trajectory
• CV tailoring: Rewrites your CV in LaTeX, highlighting the experience most relevant to each specific role
• Cover letter generation: Writes personalized cover letters that reference the company's actual work and values
• ATS optimization: Checks that your PDF passes applicant tracking system parsers (no garbled text, correct reading order)
• Interview prep: Generates STAR-format answers based on your actual experience for likely interview questions

The entire workflow runs locally in Claude Code. Your data never leaves your machine (except for the Claude API calls, which are encrypted).

How It Works: The Three-Command Workflow

The framework is built around three core commands: /setup, /scrape, and /apply. Let's walk through each one.

Step 1: /setup — Build Your Profile

First, fork the repo and run the setup command:

gh repo fork MadsLorentzen/ai-job-search --clone
cd ai-job-search

# Install dependencies for job portal scrapers
cd .agents/skills/jobindex-search/cli && bun install && cd ../../../..
# (repeat for other portals you'll use)

# Start Claude Code
claude

# Inside Claude Code:
/setup

The /setup command offers three paths:

1. Documents folder: Point it at a folder containing your CV PDF, LinkedIn export, diplomas, reference letters, and past applications. It reads everything and extracts your profile.
2. Single CV import: Paste your CV directly in chat. Good for quick starts.
3. Interview mode: Answer questions about your education, experience, skills, and career goals. Takes 15-20 minutes but produces the richest profile.

The output is a structured profile stored in markdown files:

• 01-candidate-profile.md — Education, work experience, technical skills
• 02-behavioral-profile.md — Personality traits, work style, cultural preferences
• 03-writing-style.md — Your preferred tone and phrasing for applications
• 04-job-evaluation.md — What you're looking for in a role
• 07-interview-prep.md — STAR examples from your actual experience

Pro tip: The more detail you provide, the better the output. Don't just list "Python" — describe the ML pipelines you built, the data you analyzed, the impact you had. The AI can only work with what you give it.

Step 2: /scrape — Find Matching Jobs

Once your profile is ready, search for jobs:

/scrape

This command searches multiple job portals for positions matching your profile, deduplicates results, and presents them sorted by fit score. Each listing shows:

• Job title and company
• Fit score (0-100) based on your profile
• Key strengths (why you're a good match)
• Gaps (what you're missing)
• Salary range (if available)

If you get too many results, use /rank to batch-score them all and get a prioritized shortlist:

/rank

This runs parallel agents that fetch each posting, score it against your profile, and return a ranked list with deal-breakers flagged and deadlines highlighted.

Step 3: /apply — Generate Tailored Applications

Pick a job from the list and apply:

/apply https://jobindex.dk/job/1234567

Or if the URL is blocked, paste the job description directly:

/apply
[paste job description here]

The /apply command runs a drafter-reviewer workflow:

1. Parse the posting: Extract requirements, responsibilities, company info
2. Evaluate fit: Score the match and identify your strongest selling points
3. Draft CV: Rewrite your CV in LaTeX, emphasizing relevant experience
4. Draft cover letter: Write a personalized letter referencing the company's actual work
5. Reviewer agent: A second Claude instance (with fresh context) researches the company and critiques the drafts
6. Revise: The drafter incorporates feedback
7. Compile PDFs: Generate LaTeX PDFs with lualatex (CV) and xelatex (cover letter)
8. ATS check: Extract the PDF text layer and verify it passes ATS parsers
9. Final review: Present the output with a verification checklist

The entire process takes 5-10 minutes and produces:

• A 2-page CV tailored to the specific role
• A 1-page cover letter referencing the company by name
• An ATS-optimized PDF (no garbled text, correct reading order)
• A fit analysis explaining why you're a strong candidate

Advanced Features That Set It Apart

The three-command workflow is just the beginning. ai-job-search includes several advanced features that make it more than just a "CV generator."

Relevance-Weighted CV Cutting

When your CV overflows 2 pages, most tools cut mechanically from the oldest section. ai-job-search is smarter:

It scores each bullet point by:

1. Relevance to the target posting
2. Uniqueness in the document (does this add new information?)
3. Cover letter dependency (does the cover letter reference this experience?)

Then it cuts the lowest-scoring line first. An older-role bullet that hits posting keywords survives ahead of a recent-role bullet that doesn't.

PDF Verification Loop

LaTeX templates often look fine in the .tex file but break in the PDF: job titles orphan to the next page, cover letters spill onto page 2, bullet fonts silently fall back to the body font.

The /apply command compiles and visually inspects every PDF, applying targeted fixes (\needspace, \enlargethispage, font-matching wrappers) until the layout is clean. This runs automatically on every application.

ATS Verification on the PDF Text Layer

An ATS reads the PDF's embedded text, not the rendered page — and LaTeX can silently produce PDFs whose text extracts as garbage (icon glyphs where the email should be, interleaved lines from multi-column layouts).

ai-job-search extracts the compiled CV's text layer with pdftotext and verifies:

• Contact details are present as literal text (not icon fonts)
• Reading order is sane (no interleaved columns)
• The posting's keywords are covered in the extraction

Honesty rule enforced: A keyword the profile doesn't support is acknowledged as a gap, never stuffed in.

Outcome Tracking and Calibration

After you apply, use /outcome to record what happened:

/outcome

This archives the submitted CV, cover letter, and posting text, then updates your application tracker. Once a few applications resolve (interviews, offers, rejections), it points you back to /setup to calibrate the fit framework based on what actually got interviews.

This creates a feedback loop: the more applications you track, the better the system gets at predicting which jobs you'll actually get interviews for.

Skill Gap Analysis with /upskill

Between applications, run /upskill to analyze the gap between your profile and your target roles:

/upskill

This produces:

• A prioritized heatmap of skill gaps
• A learning plan with web-searched study resources
• Time estimates for each skill

Useful for career planning: "I want to move into ML engineering — what do I need to learn, and how long will it take?"

Real-World Example: From Generic to Tailored in 8 Minutes

Let's say you're a full-stack developer applying for a senior role at a fintech company. Here's what happens:

Job posting highlights:

• 5+ years React/TypeScript experience
• Experience with payment systems or financial APIs
• Strong understanding of security best practices
• Team leadership experience

Your generic CV says:

"Full-stack developer with 6 years of experience. Built web applications using React, Node.js, and PostgreSQL. Led a team of 3 developers."

After /apply, your tailored CV says:

"Senior full-stack developer with 6 years of React/TypeScript experience. Led development of a payment processing dashboard handling $2M in monthly transactions, implementing PCI-DSS compliant authentication flows and rate-limited API endpoints. Mentored 3 junior developers through code reviews and pair programming sessions, reducing bug count by 40% over 6 months."

The AI didn't fabricate anything — it pulled specific details from your profile that match the posting's requirements and reframed them in the language the hiring manager is looking for.

The cover letter references the company by name, mentions their recent Series B funding (researched by the reviewer agent), and explains why your payment system experience makes you a strong fit for their roadmap.

Total time: 8 minutes (vs. 2-3 hours manually).

Key Benefits

• 10x faster applications: Generate tailored CVs and cover letters in 5-10 minutes instead of 2-3 hours
• Better fit scoring: AI evaluates jobs on 5 dimensions, so you only apply to roles you're actually qualified for
• ATS-optimized output: PDFs are verified to pass applicant tracking system parsers
• No hallucinations: All claims are verified against your actual profile — the system never fabricates skills or experience
• Feedback loop: Track outcomes to calibrate the fit framework based on what actually gets interviews
• Privacy-first: Runs locally in Claude Code; your data never leaves your machine (except encrypted API calls)
• Customizable templates: Use your own LaTeX CV template with /add-template
• Market-agnostic: Add job portals for your country with /add-portal
• Open source: MIT licensed, 13,800+ GitHub stars, active community

Getting Started

Ready to automate your job search? Here's the quick start:

# 1. Fork and clone
gh repo fork MadsLorentzen/ai-job-search --clone
cd ai-job-search

# 2. Install dependencies (for portals you'll use)
cd .agents/skills/linkedin-search/cli && bun install && cd ../../../..

# 3. Start Claude Code
claude

# 4. Build your profile
/setup

# 5. Find jobs
/scrape

# 6. Apply
/apply [job-url-or-description]

Requirements:

• Claude Code CLI (Anthropic subscription required)
• Python 3.10+
• Bun (for job portal scrapers)
• LaTeX distribution (TeX Live or MiKTeX) for PDF compilation
• Optional: pdftotext from poppler (for ATS verification)

Pro tips:

• Invest 20-30 minutes in /setup — the richer your profile, the better the output
• Use the interview mode for the most comprehensive profile
• Track outcomes with /outcome to improve fit predictions over time
• Run /upskill between applications to identify skill gaps

Frequently Asked Questions

Q: Is ai-job-search free?

A: The framework itself is free and open source (MIT license). However, you need a Claude Code subscription from Anthropic, which costs $20/month for the Pro plan or $100/month for the Team plan. The job portal scrapers are also free.

Q: Does it work outside Denmark?

A: Yes! The core workflow (profile building, fit evaluation, CV/cover letter generation) is language- and country-agnostic. The job portal scrapers are built for Denmark by default, but you can add portals for your market using /add-portal. The repo also includes a LinkedIn scraper that works globally.

Q: Will the AI fabricate experience I don't have?

A: No. The system has a strict honesty rule: all claims in the CV and cover letter are verified against your actual profile. If the posting requires a skill you don't have, it's acknowledged as a gap, not fabricated. The ATS check also prevents keyword stuffing.

Q: Can I use my own CV template?

A: Yes. Run /add-template and point it at your LaTeX .tex file. The command interviews you for the template's instructions (compile engine, fonts, style rules, page limit), runs a test compile, and wires it into /apply. Templates are stored with [PLACEHOLDER] tokens instead of personal data, so they're safe to commit.

Q: How does the drafter-reviewer workflow work?

A: The drafter agent writes the CV and cover letter. Then a second Claude agent is spawned with fresh context — it researches the company and critiques the drafts. The drafter revises based on feedback. This catches missed keywords, weak framing, and generic language that a single pass often leaves in.

Q: What if a job portal blocks the scraper?

A: You can paste the job description directly into /apply instead of using a URL. The framework works with any job description text, regardless of source.

Q: How do I track which applications got interviews?

A: Use the /outcome command after each application resolves (interview, offer, rejection, or silence). It archives the submitted materials and updates your tracker. Once you have enough data, it recalibrates the fit framework based on what actually worked.

Q: Can it help me identify skill gaps?

A: Yes. Run /upskill to analyze the gap between your profile and your target roles. It produces a prioritized heatmap of skill gaps, a learning plan with web-searched resources, and time estimates for each skill.

Q: Is my data private?

A: The framework runs locally in Claude Code. Your profile, CV, and applications never leave your machine except for encrypted API calls to Anthropic. The job portal scrapers make HTTP requests to the portals, but they don't send your personal data — just search queries.

Q: What LaTeX distribution do I need?

A: TeX Live (Linux/macOS) or MiKTeX (Windows). The CV compiles with lualatex (pdflatex often fails on modern MiKTeX with fontawesome5 errors); the cover letter compiles with xelatex because cover.cls requires fontspec.