Case Studies

Inside career-ops: A Job-Hunting Agent That Runs in Claude Code

Scraping jobs, scoring them A–F, tailoring CVs, tracking every application. santifer open-sourced his entire job-search workflow as a local multi-agent CLI tool—and it landed him an offer.

Font size

What Problem It Solves

santifer states it plainly in the README: after months of mass-applying and experiencing the full "AI-screened resume" gauntlet from the candidate side, he built AI tooling for job seekers.

The scope is specific—not another generic "AI job assistant":

  • Bulk-scrapes listings from Indeed, LinkedIn, and RemoteOK
  • Scores job-to-resume match quality on an A–F rubric, quantified as 1.0–5.0
  • Auto-rewrites the CV for high-scoring roles
  • Logs every application, reply, and interview in local files

The author reports evaluating 740+ postings and generating 100+ tailored CVs before landing his target offer. The repo has 66k stars on GitHub, the README is translated into 17 languages, and WIRED and Business Insider have covered it.

It's not a SaaS. It's a set of Markdown files plus a thin layer of JavaScript glue that runs inside local CLI agents like Claude Code, Codex, OpenCode, and Antigravity. Pure JavaScript, fully local.

How to Use It

The minimal flow is three steps:

git clone https://github.com/santifer/career-ops
cd career-ops
# Open this directory in Claude Code and say:
# "Scan RemoteOK for Python backend roles"

The agent reads skill definitions under .claude/, invokes scripts to pull listings, runs scoring, and generates tailored CVs automatically.

Below is a simplified version of the scraping logic from src/scrapers/indeed.js (structure matches the code posted in the README):

// src/scrapers/indeed.js — multi-source scraping example
const { loadRubric } = require('../lib/rubric');
const { callClaude } = require('../lib/llm');

async function fetchAndScore(source, query) {
  const jobs = await scrape(source, query);
  const rubric = await loadRubric('./rubrics/engineering.md');

  const scored = [];
  for (const job of jobs) {
    const prompt = `
      Use the following rubric to evaluate how well this job matches the candidate's resume.
      Output a score from 1.0–5.0 with reasoning.
      ${rubric}

      Job Description:
      ${job.description}

      Candidate Resume:
      ${job.baseCV}
    `;
    const result = await callClaude(prompt, { json: true });
    scored.push({ jobId: job.id, score: result.score, rationale: result.reason });
  }
  return scored;
}

module.exports = { fetchAndScore };

The core design takeaway from this snippet: "telling the agent what to do next" isn't baked into a complex framework. It's all written in natural-language instruction files (.claude/skills/*.md) plus a small amount of JS glue.

How It Works

A four-stage pipeline, strung together cleanly:

1. Scraper Agent
Pulls listings from multiple sources (Indeed, LinkedIn, RemoteOK, etc.) and persists them to a local SQLite or JSON file.

2. Evaluator Agent
This is the heart of the system. The A–F rubric is written in Markdown—each grade maps to a set of hard conditions, for example:

  • A (4.5–5.0): Salary range matches + fully remote + 80%+ tech-stack overlap
  • B (3.5–4.5): Salary within ±10% + remote optional + 60%+ tech-stack overlap
  • C (2.5–3.5): Significant salary gap but other conditions acceptable
  • D–F: Dealbreakers (visa-unfriendly, on-site required, zero tech-stack overlap)

The LLM outputs a 1.0–5.0 score following these rules.

3. Tailor Agent
Takes high-scoring postings (typically A and B), compares their JDs against your base CV, and asks Claude to produce a tailored version. Not a from-scratch rewrite—just adjusted wording and reordered bullets to fit the JD.

4. Tracker
Logs every application, every reply, every interview in local Markdown or CSV files, grouped by status (Applied / Read / Interviewing / Offer / Reject).

Key design choice: the rubric lives as an editable .md. Users can change scoring criteria without touching code. This is a meaningful improvement over hardcoded prompts—want to weight "remote" more heavily? Edit one line in Markdown. Want to add a "company size" dimension? Drop in a paragraph.

Strengths and Weaknesses

What works:

  • Closed loop, real results. Not a demo—the author open-sourced it after landing the offer.
  • Explainable, tunable rubric design. More on this below.
  • Local execution. Resumes and application data never leave your machine.
  • Zero learning curve for Claude Code users. The skills live as Markdown files in .claude/skills/.

What doesn't:

  • Heavy reliance on a Claude Code subscription. The README lists Codex, OpenCode, and Antigravity as alternatives, but the official skills are written for Claude Code.
  • Scoring quality depends entirely on your rubric quality. A bad rubric leads the LLM astray—no ground-truth validation.
  • Multi-agent coordination relies on prompt chaining without an explicit state machine. Long-running tasks (e.g., evaluating 100 jobs in sequence) can lose context.
  • Heavy dependence on overseas job sources (Indeed, LinkedIn, RemoteOK). Users outside those markets need to swap data sources—a hard limitation.

Compared to AutoGPT or MetaGPT, it wins on tight scope, short pipeline, and controllability. Compared to a generic scraper-plus-GPT script, it wins on the "externalized scoring standard" design—which is really what this article is about.

I Tried It

Cloned it in Claude Code and ran the demo flow:

On a 10-job sample, the scoring stage averaged 4–6 seconds per job (Sonnet). I tweaked the rubric to push "remote" weight from 30% to 50% and re-ran the sort—the ranking shifted as expected. A hybrid role that was second dropped to fourth; a fully remote role climbed to the top.

CV tailoring output quality depends on how structured your base CV is. I fed in a wall-of-text resume and got what looked like a reordered copy of the original. I fed in a version with clear bullet points and got visibly JD-targeted rewrites with much better technical keyword hits.

The more structured your rubric and base CV, the closer the tool gets to what it promises. Neither is something the tool does for you—both are prep work on your end.

Who Should Use It

Good fit:

  • Engineers based overseas with a Claude Code subscription, applying to 20+ roles per week
  • Anyone studying how to decompose a real workflow into agent steps

Poor fit:

  • Job seekers in markets with weak source coverage (the data-source limitation is real)
  • Occasional Claude Code users applying casually (overkill)
  • Anyone unwilling to write their own rubric—scoring quality lives or dies at that step

For readers thinking beyond job hunting, the more portable lesson is decomposing subjective decisions into an A–F rubric and letting an LLM score against it.

The same pattern applies to paper review, code review, backlog prioritization, and customer ticket triage. At its core, it's a minimal engineering framework for "LLM-as-judge": the rubric is the criterion, the output is a structured score with reasoning, and results are traceable, reproducible, and debuggable.

Why is this better than just prompting an LLM to "give it a score"? Because the rubric is human-reviewable, version-controlled, and team-alignable. The LLM is just the executor—the rules are yours.

Reference: career-ops GitHub repo

Source: https://github.com/santifer/career-ops