The job search is becoming a filtering problem, not a volume problem
An open-source project called career-ops is a clear example of where AI-native job hunting is heading: less spray-and-pray, more signal.
For the last decade, job hunting advice has been some variant of the same thing: apply to more places. Tune your resume for the ATS. Hit 100 applications a week. Treat it like a numbers game.
That advice is starting to look obsolete — and a small open-source project called career-ops is one of the clearest examples of why.
The premise
Career-ops is an AI-powered job search pipeline built on top of Claude Code. You paste a job URL, and it does the things you'd normally spend an evening doing yourself: reads the job description, compares it against your CV, scores the fit across ten weighted dimensions, generates a tailored ATS-friendly PDF, drafts STAR-format interview stories, researches comp, and logs the whole thing into a tracker.
It scans 45+ pre-configured company career pages (Anthropic, OpenAI, Retool, ElevenLabs, n8n, and others) across Greenhouse, Ashby, Lever, and Wellfound. It can batch-evaluate ten offers in parallel using sub-agents. There's a Go-based terminal dashboard for browsing the pipeline.
The author reports using it to evaluate 740+ offers, generate 100+ tailored CVs, and ultimately land a Head of Applied AI role.
The interesting part isn't the automation
Plenty of tools automate job applications. What makes career-ops worth paying attention to is that it's explicitly anti-spray-and-pray. From the README:
This is NOT a spray-and-pray tool. Career-ops is a filter — it helps you find the few offers worth your time out of hundreds. The system strongly recommends against applying to anything scoring below 4.0/5.
That's a meaningful inversion. The bottleneck in a modern job search isn't your ability to send applications — it's your ability to identify which of the hundreds of plausible-looking listings actually deserve a thoughtful application. LLMs are remarkably good at that kind of triage, and remarkably bad (or at least unwise) at the "blast 500 applications" version of the problem, which is exactly what's flooding recruiter inboxes and making the whole market worse for everyone.
If both sides of the market start using AI, the equilibrium shifts. Recruiters use AI to filter inbound. Candidates use AI to filter outbound. The winning move is no longer volume — it's signal.
The "agentic" part is doing real work
Career-ops uses Playwright to actually navigate career pages, not just hit APIs. It reasons about CV-vs-JD fit instead of keyword-matching. And — this is the part I find most telling about where tooling is heading — it's designed to be customized by the model itself:
The system is designed to be customized by Claude itself. Modes, archetypes, scoring weights, negotiation scripts — just ask Claude to change them. It reads the same files it uses, so it knows exactly what to edit.
The configuration surface and the agent runtime are the same files. You don't write a config schema; you tell the agent "switch the archetypes to backend engineering roles" or "add these five companies to portals.yml" and it edits its own scaffolding. That's a pattern worth watching: tools whose primary user interface is natural language directed at the tool's own source files.
Human-in-the-loop, on purpose
One detail that's easy to miss: career-ops never actually submits an application. It evaluates, drafts, scores, and recommends. You hit send. The README is explicit that the first few evaluations will be bad because the system doesn't know you yet — you have to feed it your CV, your career story, your proof points, the things you want to avoid. It compares the experience to onboarding a new recruiter.
This is the right shape for AI tooling in high-stakes personal workflows. The model is a research analyst, not an autonomous actor. The cost of a bad automated application — to your reputation, to a recruiter's time — is higher than the cost of clicking submit yourself.
What to take from it
You don't have to use career-ops to take the lesson. The broader point is:
- The job market is becoming a two-sided AI filtering problem. If you're still optimizing for volume, you're optimizing for the previous era.
- The right place to put AI is at the triage step, not the submission step. Use it to decide what's worth your attention.
- Onboard your tools like you'd onboard a person. A model that knows your career story, your non-negotiables, and your proof points will give you dramatically better recommendations than one that's seen your resume once.
- Configuration-as-conversation is a real pattern now. When the agent can edit its own scaffolding, "setup" stops being a separate phase.
Career-ops is MIT-licensed and on GitHub at santifer/career-ops. Even if you never run it, the repo is worth a read as a concrete example of what an agent-native personal tool actually looks like.