Career-Ops: The Claude Code Skill That Hunts Jobs For You

Job hunting in 2026 is broken in the same ways it was broken in 2016. You spend hours rewriting your CV for each application, copy-pasting the same fields into 12 different Greenhouse forms, forgetting which companies you applied to last week, and second-guessing whether the offer in front of you is actually good.

Santiago Ferrer (@santifer) decided to fix it the way developers fix things in 2026 — by building a Claude Code skill that turns the entire mess into a structured pipeline. It's called Career-Ops, and it's one of the most practical applications of agentic engineering we've seen this year.

Key Takeaways

• Career-Ops scores job offers across 10 weighted dimensions using a structured A-F grading system, removing emotion from the decision
• 45+ company portals come pre-configured for automatic scanning across Greenhouse, Ashby, Lever, and other platforms
• CV generation is ATS-optimized per job description, dramatically improving applicant tracking system match rates
• A single slash command (/career-ops) provides 12+ modes including scan, pdf, batch, and dashboard
• Human-in-the-loop by design — the AI recommends, you decide. It never auto-applies on your behalf.

What is Career-Ops?

Career-Ops is an AI-powered job search and career management system built entirely on Claude Code. Instead of treating the job hunt as a series of one-off actions, it treats it as a pipeline with five distinct stages: discovery, evaluation, application, tracking, and negotiation.

Each stage is automated where automation makes sense and kept human where judgment matters. The result is a system where you can spend 30 minutes a day reviewing AI-generated recommendations instead of 4 hours rewriting CVs and refreshing job boards.

The skill is open source (MIT licensed) and runs locally on your machine. No SaaS subscription, no third-party data sharing — just a Claude Code skill, a Node.js backend, and a Go-based terminal UI.

How does the offer evaluation work?

This is the most interesting part of Career-Ops. Instead of relying on gut feeling or salary alone, it scores every job offer across 10 weighted dimensions:

Each dimension gets graded A through F. The grades are weighted by your personal priorities (defined in config/profile.yml), then aggregated into a final score. The output isn't just a number — it's a structured breakdown showing exactly why an offer scored where it did.

This is the kind of analysis that would take you 2-3 hours of soul-searching per offer. Career-Ops does it in 30 seconds and shows its work.

How does CV generation work?

Career-Ops doesn't just spit out a generic CV. It reads the job description, extracts the key requirements and keywords, then tailors your master CV to maximize ATS (Applicant Tracking System) match rates.

The flow looks like this:

/career-ops pdf https://job.lever.co/example/some-role

What happens next:

1. Scrapes the job description using Playwright
2. Extracts requirements — both explicit ("5+ years Python") and implicit ("works with distributed systems")
3. Reads your master CV from data/master-cv.md
4. Reorders and rewrites bullets to emphasize matching experience
5. Injects keywords naturally without keyword stuffing
6. Generates a PDF using a clean LaTeX template
7. Saves to output/{company}-{role}.pdf with timestamp

The result is an ATS-optimized CV that still reads naturally to humans. According to recent ATS research, tailored CVs see 60-80% higher pass-through rates compared to generic versions.

Automated portal scanning

Career-Ops ships with 45+ pre-configured company integrations across the major hiring platforms:

• Greenhouse — Used by Stripe, Airbnb, Coinbase, and hundreds of others
• Ashby — The newer platform favored by AI-native companies
• Lever — Popular with mid-stage startups
• Workday, SmartRecruiters — Enterprise companies

Running /career-ops scan triggers a Playwright-powered scraper that visits each configured portal, pulls new job postings, deduplicates against your existing pipeline, and flags openings that match your profile.

This is where the parallel processing matters. Without parallelization, scanning 45 portals would take 20+ minutes. Career-Ops uses batch workers to fan out the requests and complete the scan in under 3 minutes on typical hardware.

The terminal UI dashboard

Most job tracking tools are either spreadsheets (too messy) or SaaS apps (too heavy). Career-Ops takes a third path: a terminal UI built in Go using Bubble Tea, the popular TUI framework from Charm.

The dashboard shows:

• Pipeline view — Your applications grouped by status (applied, screening, interview, offer, rejected)
• Filter and sort — By company, role, score, application date, or any custom field
• Detail panes — Full job description, your CV version, interview notes
• Quick actions — Update status, add notes, archive, or trigger re-evaluation

It's the kind of interface that respects your time. Keyboard-driven, fast, and exactly as complex as it needs to be.

How does it compare to other career tools?

The trade-off is clear: SaaS tools give you polish and zero setup, Career-Ops gives you full control and zero monthly fees. For developers who already use Claude Code daily, the setup cost is minimal — you're essentially adding another slash command to your existing workflow.

Why this skill matters for the AI Skills ecosystem

Career-Ops is a perfect example of where we think AI skills are heading. It's not a generic chatbot or a "do everything" agent. It's a focused tool that solves one specific problem (job hunting) really well by combining several AI capabilities:

• Web scraping (Playwright)
• Document understanding (job descriptions)
• Document generation (tailored CVs)
• Structured evaluation (scoring rubrics)
• State management (application pipeline)

Each of these is a building block. Career-Ops stitches them together into a workflow that actually changes how you do something. That's the killer-app pattern for AI skills, and it's why we're highlighting it.

If you're building your own Claude Code skills, study Career-Ops. The way it handles configuration, the way it separates AI recommendations from human decisions, and the way it uses a terminal UI for power users — these are patterns worth copying.

For more on building skills like this, see our guides on creating custom skills and why skills beat fine-tuning.

Installation and getting started

The install process takes about 5 minutes:

git clone https://github.com/santifer/career-ops.git
cd career-ops
npm install
npx playwright install chromium
cp config/profile.example.yml config/profile.yml
cp templates/portals.example.yml portals.yml

Then edit config/profile.yml to set your job preferences (target roles, salary range, location, weighted priorities), and portals.yml to enable the company portals you want to track.

Once configured, the slash commands work from any Claude Code session:

/career-ops scan          # Scan portals for new openings
/career-ops evaluate <job-url>  # Score a specific opportunity
/career-ops pdf <job-url> # Generate tailored CV
/career-ops batch         # Process multiple in parallel
/career-ops dashboard     # Launch the TUI

The full skill listing with related skills and install command is available at aiskill.market/skills/career-ops.

Frequently Asked Questions

Does Career-Ops auto-apply to jobs?

No. This is by design. Career-Ops follows a "human-in-the-loop" architecture where the AI surfaces opportunities, scores them, and prepares application materials — but you make the final decision and submit applications yourself. This avoids the spam problem that plagues auto-apply tools and ensures you only apply to jobs you actually want.

How does it handle privacy?

Everything runs locally. Your CV, application history, salary data, and personal preferences never leave your machine. There's no telemetry, no analytics, no third-party API calls except to the job portals themselves. If you're privacy-conscious, this matters.

Will it work for non-developer roles?

The current pre-configured portals lean toward tech companies, but the underlying system is role-agnostic. You can add any portal that exposes job listings (most do). The CV generation works for any field — it's the scoring rubric and master CV that determine the output, not hardcoded assumptions about software engineering.

Can I customize the scoring dimensions?

Yes. The 10 dimensions are defined in config/scoring.yml and you can add, remove, or reweight them. If you care more about commute time than equity, change the weights. If you want to add a "team diversity" dimension, add it. The flexibility is the point.

How does it integrate with existing job tracking tools?

Career-Ops exports its pipeline data as JSON, which you can pipe into Notion, Airtable, or any other tool. It doesn't replace your existing systems unless you want it to — many users run it alongside their current workflow as a discovery and evaluation layer.

What's next for the Career-Ops project

Santiago has hinted at future features including LinkedIn integration (the holy grail of automated job scanning), interview prep based on your application history, and salary negotiation support that uses real comp data from sources like Levels.fyi. The roadmap suggests Career-Ops is moving from a job search tool toward a full career management platform.

For developers who want to contribute, the GitHub repo is open and accepting PRs. The codebase is well-organized and documented, making it a good starting point for anyone interested in building Claude Code skills with multiple integrated services.

---

Career-Ops is now featured in the AI Skill Market. View the full skill listing or browse all productivity skills in the marketplace. Building a similar tool? Submit your own skill to share it with the community.

Sources

• Career-Ops GitHub Repository — Santiago Ferrer
• Claude Code Documentation — Anthropic
• Playwright for Node.js — Microsoft
• Bubble Tea TUI Framework — Charm
• Jobscan ATS Research — Jobscan