Career-Ops on Claude Code: The Complete 2026 Reference (14 Skill Modes, 10 Evaluation Dimensions, 3 Forks Compared)

In April 2026, Santiago Fernández de Valderrama open-sourced Career-Ops — a Claude Code-native job-search system that took his own search from 740 evaluated listings to 1 signed offer for a Head of Applied AI role. Within a week, the repository crossed 43,800 stars. As of May 14, 2026 it sits at 44,554 stars and 9,353 forks, with dozens of community variants.

This article is the complete public reference for Career-Ops as a Claude Code Skill system — assembled from the GitHub README.md, AGENTS.md, the author’s santifer.io writeup, his dev.to deep-dive, and the source of three notable community forks. We catalog all 14 skill modes, the 10 evaluation dimensions (blocks A–G), the multi-agent architecture that powers the parallel batch processor, and how the main community forks diverge in scope and supported CLIs.

If you are designing Claude Code skill bundles, considering Career-Ops for your own search, or comparing it against alternative implementations, this is the lookup page.

What Is Career-Ops?

Career-Ops is a Claude Code Skill bundle that turns job hunting from a manual pipeline (“read JD → adapt CV → fill the form → log it somewhere”) into an agentic pipeline. As the author puts it in the GitHub README: “I spent months applying to jobs the hard way. So I engineered the system I wish I had.”

The published metrics from the author’s March 2026 search:

The numbers matter for three reasons. First, the 6.6:1 evaluate-to-apply ratio is intentional — Career-Ops is designed as a filter, not a spray-and-pray tool. Second, deduplication absorbed the cost of “the same job posted on three portals,” which the author calls the single highest-leverage improvement over scoring optimization. Third, the system never auto-submitted anything; human review gates every application.

The repository on GitHub: santifer/career-ops. Default branch main, MIT-licensed with a permissive trademark policy for community use.

The 14 Skill Modes (Full Catalog)

Career-Ops is organized as 14 modes, each a separate Markdown skill file in modes/. The author’s design rule is explicit in his dev.to writeup: “Each one loads only the context it needs. auto-pipeline skips contact rules. apply skips scoring logic.” Mode-per-task isolation is what makes the system maintainable.

The current 14 modes (May 2026):

The system originally shipped with 12 modes at the April 2026 dev.to launch — Training and Project were added later as the system evolved. This is consistent with the author’s stated philosophy that modes should evolve independently without breaking the rest of the bundle.

The 10 Evaluation Dimensions (Blocks A–G)

The Oferta mode evaluates a job against the user’s CV and profile across structured blocks. Reading the public AGENTS.md, the rubric is explicit:

• Scoring scale: 1–5 across 10 weighted dimensions, ultimately graded A–F.
• Threshold: scores below 4.0/5 trigger a recommendation against applying unless the user overrides. The author’s words: “every application a human reads costs someone’s attention. Only send what’s worth reading.”
• Block G — Posting Legitimacy: a tier classification (T1–T4) for whether the listing is a real, active opening — not a ghost job or scraper aggregator.
• Archetype matching: the user defines target archetypes (e.g., “Head of Applied AI”, “Senior Backend Engineer”) in modes/_profile.md. Every job is matched against these archetypes plus user preferences for location, comp, and culture.

The other blocks evaluate role fit, compensation alignment, growth trajectory, culture, and location policy. The exact split is encoded inside modes/oferta.md in the repo for users to inspect and tune locally — Career-Ops treats the rubric as user-tunable, not a black box.

Multi-Agent Architecture: How Claude Code Powers It

Career-Ops is not a workflow built on top of Claude Code. It is structured as a Claude Code agent system. The architecture has four layers that map directly to Claude Code primitives.

Layer 1: AGENTS.md and CLAUDE.md

The repository ships both:

• AGENTS.md — the canonical agent instructions, portable across Claude Code, Codex CLI, Gemini CLI, and OpenCode.
• CLAUDE.md — a thin wrapper that imports AGENTS.md so Claude Code picks it up via the standard discovery path.

This dual-file pattern is becoming a common convention in 2026 — see also our AGENTS.md vs CLAUDE.md guide for the broader pattern.

Layer 2: Modes as Skill Files

Each of the 14 modes lives in modes/ as a standalone Markdown file. The author’s design rule from the README is the data contract:

“When the user asks to customize anything (archetypes, narrative, negotiation scripts, proof points, location policy, comp targets), ALWAYS write to modes/_profile.md or config/profile.yml.”

User-layer files (cv.md, _profile.md, profile.yml, tracker reports) are strictly separated from system-layer files (shared modes, scripts, templates). This means Career-Ops can ship updates without overwriting personalization — a pattern worth copying for any Skill bundle with persistent user state.

Layer 3: Sub-Agent Parallelism via claude -p

The Batch mode is where the system gets aggressive about throughput. A conductor process spawns independent worker processes; each worker uses claude -p (Claude Code’s headless prompt mode) with a self-contained worker prompt at batch-prompt.md. The author quotes the worker loop directly in his dev.to article:

“Each worker: 1. Claims a URL from the queue (lock file prevents doubles). 2. Runs auto-pipeline. 3. Writes result to batch-state.tsv.”

The design is resumable and fault-tolerant — if a worker crashes, the lock file is released and another worker picks up the URL. This is the practical pattern most Skill authors don’t implement because writing concurrent code in Claude Code feels uncomfortable; Career-Ops shows it works at 10+ workers in parallel.

Layer 4: Playwright as the Ground-Truth Verifier

This is the single instruction in AGENTS.md most likely to surprise readers:

“NEVER trust WebSearch/WebFetch to verify if an offer is still active.”

The mandated verification flow is: open the URL in Playwright, take a snapshot, confirm both the job description and the Apply button are present. Only in batch/headless contexts where Playwright is unavailable does the system fall back to WebFetch — and the report is then explicitly marked **Verification:** unconfirmed (batch mode).

This is the reason npx playwright install chromium is part of the install steps. It is also why Career-Ops won’t run as a pure stdio MCP server — it needs a browser.

Quality Guardrails: Why Career-Ops Refuses to Auto-Submit

The author has been explicit and repeated about this in every public surface — README, AGENTS.md, dev.to, his personal blog: the system drafts and prepares; it never auto-submits. From AGENTS.md:

“NEVER submit an application without the user reviewing it first.”

Three layers of guardrails enforce this:

1. Score threshold. Below 4.0/5, the system recommends against applying. The user can still override.
2. Apply mode pauses. Even when Apply automates form filling, it stops at the submit button for user approval.
3. Tracker honesty. The canonical statuses (Evaluated, Applied, Responded, Interview, Offer, Rejected, Discarded, SKIP) make it visible when the user is the bottleneck vs. when the AI is.

This puts Career-Ops on the analysis-automation side of the line that Santiago repeatedly draws — “Career-Ops automates analysis, not decisions.” It is a deliberate philosophical choice with concrete UX consequences: every approval prompt is friction by design.

Installation and Onboarding

The setup is shorter than the feature list suggests:

# 1. Clone the repository
git clone https://github.com/santifer/career-ops.git
cd career-ops && npm install

# 2. Install Playwright (mandatory — see Verification above)
npx playwright install chromium

# 3. Verify prerequisites
npm run doctor

# 4. Configure your profile and portals
cp config/profile.example.yml config/profile.yml
cp templates/portals.example.yml portals.yml

# 5. Add your CV
# Create cv.md in project root, in markdown.

Four baseline files must exist before the first evaluation runs:

1. cv.md — your CV in markdown.
2. config/profile.yml — name, location, target roles, salary targets.
3. modes/_profile.md — user-specific scoring weights and narrative.
4. portals.yml — job portal configuration.

If any of the four is missing, the agent enters guided onboarding, asking the user to provide the CV, profile details, portal preferences, and contextual answers about strengths, motivations, and deal-breakers. The onboarding sequence is documented in the README and is one of the smoother examples of “agent that asks the right questions” in the Skills ecosystem.

Three Community Forks Compared

Career-Ops has spawned a wide community fork tree (9,353 forks as of May 14, 2026). Three of them are substantive — different scope, different audience, different supported CLIs.

Comparison Table

santifer/career-ops (Original)

The reference implementation. 14 modes, Go dashboard, Playwright-based verification, parallel batch worker. This is what every other variant is measured against. Target user: technical job seekers willing to set up Playwright and run an agent on their own machine.

poferraz/career-ops

A re-thinking of the concept as a career coaching skill rather than an end-to-end pipeline. Four operational stages: Motivational Interviewing → Smart Routing → Anti-Slop Quality Gate → Session Memory. The Quality Gate scores every output on 5 dimensions (directness, rhythm, trust, authenticity, density) and auto-rewrites anything below 35/50. Claims tier-ranked T1–T4 with peer-reviewed sourcing for all advice — T4 (unverified) content is excluded entirely.

Local-first by design: no API keys required, no MCP servers, no cloud dependencies. Supports a broader CLI matrix than the original (adds Cursor, Antigravity, Windsurf).

andrew-shwetzer/career-ops-plugin

An adaptation for Claude Cowork (Anthropic’s conversational interface). Nine bundled skills: posting evaluation, resume tailoring, portal scanning, pipeline triage, application tracking, form-fill assistance, company research, outreach drafting, side-by-side comparison.

Target audience is explicitly cross-industry — the README lists tech, healthcare, finance, legal, creative, and trades as covered. If you’re a non-engineer who wants the workflow without setting up a Go dashboard, this is the version to look at first.

How to Pick

• You’re a developer running Claude Code locally and want the full pipeline: santifer/career-ops.
• You want coaching-grade resume and interview prep without setup overhead: poferraz/career-ops.
• You’re on Claude Cowork or want a non-technical entry point: andrew-shwetzer/career-ops-plugin.
• You want the original, packaged for one-line install: career-ops/career-ops.

Localization

The original Career-Ops ships with three additional language modes beyond English:

• German (DACH) — DACH market norms (Bewerbungsmappe, Ausbildung references).
• French (Francophone) — France, Belgium, Quebec market norms.
• Japanese (Japan) — 履歴書 / 職務経歴書 norms, keigo-appropriate cover letters.

Localization is activated by user request or auto-detected from the job posting’s language. For Japanese-market readers, the inclusion of native 履歴書 templates is a meaningful differentiator — most English-first job-search tools do not respect the dual-document Japanese resume convention.

Common Pitfalls and Best Practices

From a careful reading of the public AGENTS.md and the author’s writeups, these are the failure modes most likely to bite a new user:

1. Skipping the Playwright install. Without it, the verification mandate falls through to WebFetch — and Search results lie about ghost jobs. Run npx playwright install chromium first.
2. Editing system files instead of _profile.md. The data-contract rule exists because system files get overwritten on update. Always personalize via modes/_profile.md or config/profile.yml.
3. Treating the score as gospel. The 4.0/5 threshold is the system’s recommendation, not a hard rule. Use it as a filter, then read every JD that crosses the line manually.
4. Running Batch on too small a queue. The parallel worker overhead is worth it only when you have a real backlog (the author’s batch ran 122 URLs at once).
5. Forgetting the dedup layer. 680 URLs deduplicated across the author’s pool is the single largest time saver — disable it and you’ll re-evaluate the same job three times.
6. Auto-submitting in Apply. The system pauses at submit on purpose. Don’t paper over the approval gate.

FAQ

What is Career-Ops?

Career-Ops is a Claude Code Skill bundle for AI-assisted job search, built by Santiago Fernández de Valderrama. It ships 14 skill modes that handle portal scanning, A–F evaluation, ATS-optimized CV generation, parallel batch processing, application tracking, and interview prep. The system automates analysis, not decisions — every application requires explicit human approval.

How many GitHub stars does Career-Ops have?

As of May 14, 2026, the santifer/career-ops repository has 44,554 stars and 9,353 forks. The project hit 43,800 stars in its first week of public release.

Is Career-Ops only for Claude Code?

The original santifer/career-ops ships with AGENTS.md and supports Claude Code, Codex CLI, Gemini CLI, and OpenCode. Community forks extend this: poferraz/career-ops adds Cursor, Antigravity, and Windsurf; andrew-shwetzer/career-ops-plugin targets Claude Cowork specifically.

Does Career-Ops auto-submit job applications?

No. Both AGENTS.md and the author’s writing explicitly forbid auto-submission. Even in the Apply mode that automates form filling, the system pauses before the submit button and requires user confirmation. The design principle is “analysis automation, not decision automation.”

What are the 14 skill modes?

Oferta (single evaluation), PDF (ATS-optimized CV), Scan (portal scanner), Batch (parallel processing), Tracker (status management), Apply (form fill with approval pause), Pipeline (queue orchestration), Contacto (LinkedIn outreach), Deep (company research), Training (course evaluation), Project (portfolio assessment), Interview (STAR prep), Negotiate (salary scripts), Dashboard (terminal UI). The system originally shipped with 12 modes and grew to 14 as the codebase matured.

How does parallel batch processing work?

A conductor process spawns multiple workers, each running claude -p with a self-contained batch-prompt.md. Workers claim URLs from a shared queue using lock files — exactly one worker per URL — and write results to batch-state.tsv. The design is resumable and fault-tolerant: a crashed worker releases its lock, and another worker picks up the URL.

Why does Career-Ops require Playwright?

Because AGENTS.md mandates browser-based verification of every listing: “NEVER trust WebSearch/WebFetch to verify if an offer is still active.” Playwright opens the URL, snapshots the page, and confirms both the JD and the Apply button are present. Without this step, ghost jobs and stale postings leak into the pipeline and waste evaluations.

Can I use Career-Ops for non-tech job searches?

Yes. The santifer/career-ops original is technical in scope but supports any archetype defined in modes/_profile.md. For an explicitly industry-agnostic experience (tech, healthcare, legal, creative, trades), andrew-shwetzer/career-ops-plugin is built for cross-industry use on Claude Cowork.

Where does user data live? Is it private?

Local-first. Your CV (cv.md), profile (config/profile.yml), and tracker live in your local repo. The system sends prompts directly to the AI provider you configure (Anthropic, OpenAI, or Google Gemini) — no Career-Ops cloud service is in the loop. poferraz/career-ops reinforces this: no API keys, no MCP servers, no cloud dependencies.

Related Articles

• AGENTS.md vs CLAUDE.md: The Definitive 2026 Comparison
• 15 Best Claude Code Skills You Should Install in 2026
• Claude Code Subagents Best Practices 2026
• Claude Code Best Practices: The Complete Guide
• How to Write a CLAUDE.md File
• Browse 165+ Real AI Coding Rules

External References

• santifer/career-ops on GitHub — Original repository
• Santiago’s project writeup at santifer.io — Author’s narrative
• poferraz/career-ops — Coaching-focused fork
• andrew-shwetzer/career-ops-plugin — Claude Cowork plugin variant