Career-Ops: Turn Claude Code Into a Job-Search Command Center

The job hunt is asymmetric: companies run AI to filter thousands of candidates, while candidates still track applications in a spreadsheet and rewrite the same CV by hand. Career-Ops flips that asymmetry — it gives the candidate an agentic pipeline that evaluates offers, tailors a CV per listing, scans portals, and tracks the whole funnel, all from an AI coding CLI.

Its author, Santiago, reports building it for his own search and using it to evaluate 740+ offers, generate 100+ tailored CVs, and land a Head of Applied AI role (case study). Treat that as a self-reported n=1 result, not a benchmark — but the design is interesting regardless. This post covers what it is, how to run it, how it stacks up against the alternatives, and where to be careful.

What it is

Career-Ops (by santifer, MIT-licensed) turns Claude Code (and OpenCode; Codex “soon”) into a job-search command center. It’s not a hosted service — it’s a local repo of agent modes, templates, and scripts that the AI drives. The core pieces:

A structured A–F evaluation of each offer across weighted dimensions (role match, gaps, level strategy, comp research, personalization, interview prep).
ATS-optimized CV generation — a tailored PDF per job description, via an HTML template rendered with Playwright.
A portal scanner for Greenhouse, Ashby, Lever, Wellfound and company pages (45+ companies and ~19 queries pre-configured).
Batch processing that evaluates many offers in parallel with claude -p sub-agent workers.
A single tracker (markdown/TSV) with dedup and integrity checks, plus a Go-based terminal dashboard to browse it.

Crucially, it’s framed as a filter, not a spray-and-pray tool: it’s meant to surface the few offers worth your time, and the system actively recommends against applying to anything it scores below 4.0/5.

Why it matters

Reasoned fit, not keyword matching. The agent reads your cv.md against the job description and reasons about match and gaps, rather than counting keywords.
Human-in-the-loop by design. The AI evaluates and recommends; you decide and act. Per the project, it never submits an application for you.
Self-customizing. Modes, archetypes, scoring weights and negotiation scripts are plain files — and the system is designed so you ask Claude to edit them (“change the archetypes to backend roles”), because it reads the same files it runs.
Local and private. Your CV and personal data stay on your machine and go only to the AI provider you choose; there’s no backend collecting anything.
More than CVs. It also builds an interview “story bank” (STAR + reflection), negotiation scripts, and does deep company research.

How it works

You paste a job URL or description; the pipeline classifies the role into an archetype, runs the A–F evaluation against your CV, then emits three artifacts — a markdown report, a tailored PDF, and a tracker entry:

You paste a job URL or description
        │
        ▼
  Archetype detection  (LLMOps / Agentic / PM / SA / FDE / …)
        │
        ▼
  A–F evaluation       (match, gaps, comp research, STAR stories; reads cv.md)
        │
   ┌────┼────┐
   ▼    ▼    ▼
 Report  PDF  Tracker

The agent uses Playwright to navigate career pages and the portal APIs, reasons over your CV, and writes everything back to local files. There’s no server in the loop — just your CLI, your AI provider, and your filesystem.

Getting started

It’s a clone-and-configure setup (Node, plus Playwright’s Chromium for PDFs):

git clone https://github.com/santifer/career-ops.git
cd career-ops && npm install
npx playwright install chromium   # needed for PDF generation
npm run doctor                     # validate prerequisites

cp config/profile.example.yml config/profile.yml   # your details
cp templates/portals.example.yml portals.yml        # your target companies
# create cv.md with your CV in markdown

Then open Claude Code in the folder and let it personalize the system to you, before running the slash command:

claude
# "Update my profile with this CV", "add these 5 companies to portals.yml"…
# then: /career-ops   (or just paste a job URL)

/career-ops exposes modes like scan, pdf, batch, tracker, apply, deep (company research) and contacto (outreach message).

In practice

Triage a portal dump. Run /career-ops scan to pull new listings from your configured companies, then batch to score them in parallel — and only look closely at the handful above 4.0.
Tailor before you apply. Paste the JD of a role you like; get a fit report, the gaps to address in your cover note, and an ATS-tuned PDF that mirrors the listing’s language — which you then review and edit before sending.

The value isn’t “apply to more jobs faster.” It’s “spend your attention on the few that fit, with the prep already drafted.”

How it compares

Approach	What you get	Tradeoff
Career-Ops	scoring + tailored CVs + portal scan + tracking, you decide	real setup and personalization; evidence is n=1
Spreadsheet + manual	total control, zero tooling	slow, no evaluation help, you rewrite every CV
Spray-and-pray auto-appliers	raw volume of submissions	low quality, spammy, real ToS/account risk — the opposite philosophy
Generic “AI resume” tools	a quick one-off CV rewrite	no scoring, no pipeline, no portal scanning

Be fair to the alternatives: a spreadsheet is dead simple and fully in your control, and a generic resume tool is faster if all you want is one polished CV. Career-Ops earns its complexity only if you’re running a real, sustained search and want the evaluation/tracking layer — and, pointedly, it’s the anti-thesis of the mass auto-appliers, optimizing for fewer, better applications.

Tradeoffs

Evidence is anecdotal. The headline results are the author’s own search (n=1), not a controlled study. It may or may not transfer to your field or market.
Cold start. The project says the first evaluations “won’t be great” until you feed it your CV, story, and preferences. It’s onboarding, not plug-and-play.
Hallucination is a real risk here. The README itself warns the model “may hallucinate skills or experience.” On a job application that’s not a cosmetic bug — always review the generated CV and report before submitting.
Third-party ToS. Scanning and form-filling on Greenhouse, Lever, LinkedIn, etc. must respect their terms; the project is explicit that misuse (spamming, overwhelming ATS) is on you.
Setup and lock-in. It’s Claude-Code-centric (OpenCode supported, Codex pending), needs Node + Playwright, and you pay your AI provider for the evaluations. Portal scrapers are also inherently fragile as sites change.

Takeaway

Career-Ops is a thoughtfully-built, local-first agentic pipeline for running a serious job search — scoring, tailoring, scanning and tracking — with a clear “filter, don’t spam” philosophy and you firmly in the loop. It’s worth it if you’re deep in a search and willing to invest in personalizing it; it’s overkill for a one-off CV touch-up, and its track record is one person’s, so calibrate expectations and review everything the AI writes before it goes out with your name on it.