OSS Adoption & Customization

Career-Ops: Finding the Right Tool, Making It Mine

Career-Ops is an open-source multi-agent job search tool created by santifer. I evaluated it against alternatives, forked it, customized the scoring, archetypes, and CV templates for my profile, and now run it daily. This is how I find, adopt, and optimize open-source tools — the same skill I bring to any engineering team.

Joseph Blas
Mar 17, 202618 min read
Career Pipeline: tracker dashboard with 516 evaluated offers, scores 4.0-4.5, companies like Datadog, Langfuse, OpenAI, LangChain
Open-source tool — forked & customized

12

Modes

10

Dimensions

3

Target tracks

10

Years AV

5+

Years AI/Code

0 stars0 forksView on GitHub

Career-Ops is an open-source AI job search tool created by santifer. I forked it, customized scoring weights, target archetypes, CV templates, and portal configurations for my career profile, and run it in production daily. This page showcases my process for evaluating, adopting, and optimizing open-source tooling.

Credit where it's due: Career-Ops was created by santifer (santifer.io). I did not build this system — I found it, recognized it solved my problem, forked it, and made it mine. The ability to evaluate open-source tools, understand their architecture, and customize them for specific needs is the same skill set behind every CI/CD pipeline, every infrastructure stack, and every AI workflow I've ever shipped.

The best engineers don't build everything from scratch — they find the right tool, understand how it works, and make it fit their needs. After 10 years building autonomous vehicle systems at Google, Uber, and Pronto.ai, followed by 5+ years learning AI tools, code, and building personal and client projects, I needed an efficient way to target AI Developer and Autonomous Systems roles. Instead of building a job search tool from zero, I evaluated what was out there, found Career-Ops (an open-source multi-agent system by santifer), and customized it for my workflow.

I forked the repo, configured the scoring weights for my target roles, defined custom archetypes (AI Developer, Autonomous Systems, Embedded/Robotics), set up portal scanning for 45+ companies, customized the CV template with my proof points, and tuned the evaluation pipeline. The same approach I'd take adopting any open-source tool on a team: evaluate, fork, configure, optimize, operate.

The Problem#

Searching for AI Developer, Autonomous Systems, and Embedded/Robotics roles means navigating a fragmented market. Each offer requires reading the JD, mapping your skills against requirements, adapting the CV, writing personalized responses, and filling 15-field forms. Multiply that by 10 offers per day.

1

Repetitive reading.

70% of offers are a poor fit. You find out after reading 800 words of JD.

2

Generic CVs.

A static PDF cannot highlight the proof points relevant to each specific offer.

3

Manual forms.

Every platform asks the same questions in different formats. Copy-paste 15 times per application.

4

No tracking.

Without a system, you forget where you applied. Duplicate effort or lose follow-up entirely.

5

Zero feedback.

Apply, wait, and never know if the problem was fit, the CV, or timing.

6

Cross-domain targeting.

AI, Autonomous Systems, and Embedded roles live on different boards, use different keywords, and attract different recruiters. One search strategy does not cover all three.

The work is not hard. It is repetitive. The smart move isn't building a solution from scratch — it's finding the right open-source tool and making it yours.

The 12 Modes — Multi-Agent System#

Career-Ops is not a script or an auto-apply bot. It is a multi-agent system with 12 operational modes, each a Claude Code skill file with its own context, rules, and tools. An agent that reasons about the problem domain and executes the right action.

Why Modes, Not One Prompt

Precise context.

Each mode loads only the information it needs. auto-pipeline skips contact rules. apply skips scoring logic.

Testability.

One mode gets tested in isolation. Changing PDF logic never touches evaluation.

Independent evolution.

Adding a new mode never breaks existing ones. Training mode shipped 3 weeks after first deploy.

auto-pipeline

Full pipeline: extract JD, evaluate A-F, generate report, PDF, and tracker entry.

oferta

Single-offer evaluation with 6 blocks: summary, CV match, level, compensation, personalization, interview.

ofertas

Multi-offer comparison and ranking.

pdf

ATS-optimized PDF personalized per offer with proof points and keywords.

pipeline

Batch URL processing from inbox.

scan

Offer discovery: navigates job boards and careers pages of target companies. Many offers never appear on aggregators.

batch

Parallel processing with conductor + workers. Simultaneous URLs in queue.

apply

Interactive form-filling with Playwright. Reads the page, retrieves cached evaluation, generates responses.

contacto

LinkedIn outreach helper.

deep

Deep company research.

tracker

Application status dashboard.

training

Evaluates courses and certifications against the North Star.

Scan mode in action: Claude Code agent launching DailyRemote search with 8 queries, reading pipeline.md and scan-history.tsv for dedup
Scan mode: background agent searching AI/LLM offers on DailyRemote with automatic dedup

10-Dimension Scoring#

Every offer runs through an evaluation framework with 10 weighted dimensions. The output: a numeric score (1-5) and an A-F grade. Not all dimensions carry equal weight — Role Match and Skills Alignment are gate-pass: if they fail, the final score drops.

DimensionWhat It MeasuresWeight
Role MatchAlignment between requirements and CV proof pointsGate-pass
Skills AlignmentTech stack overlapGate-pass
SeniorityStretch level and negotiabilityHigh
CompensationMarket rate vs targetHigh
GeographicRemote/hybrid/onsite feasibilityMedium
Company StageStartup/growth/enterprise fitMedium
Product-Market FitProblem domain resonanceMedium
Growth TrajectoryCareer ladder visibilityMedium
Interview LikelihoodCallback probabilityHigh
TimelineClosing speed and hiring urgencyLow
Real evaluation: Datadog Staff AI Builder, MCP Services — Score 4.55/5, archetype AI Platform + Agentic Workflows, role summary with 7 dimensions
Real evaluation: Datadog Staff AI Builder — score 4.55/5, detected archetype, structured role summary
CV Match: table of 6 JD requirements mapped against CV proof points with strength rating (Strong/Very Strong/Moderate)
Block B) CV Match: each JD requirement mapped against real CV proof points
CV Match (cont.) + Gaps and Mitigation: requirements 7-10 and gap analysis with severity and mitigation plan
CV Match (cont.) + Gaps: the system identifies gaps and proposes mitigation with severity
Gaps (cont.) + Level and Strategy: IC5 level detection, "Sell Staff without lying" plan with experience framing
Block C) Level and Strategy: seniority detection + honest positioning plan

Score Distribution

21

Score >= 4.5 (A)

52

Score 4.0-4.4 (B)

71

Score 3.0-3.9 (C)

51

Score < 3.0 (D-F)

74% of evaluated offers score below 4.0. Without the system, I would have spent hours reading JDs that never fit.

The Pipeline#

auto-pipeline is the flagship mode. A URL goes in, and out comes an evaluation report, a personalized PDF, and a tracker entry. Zero manual intervention until final review.

1

Extract JD.

Playwright navigates to the URL, extracts structured content from the offer.

2

Evaluate 10D.

Claude reads JD + CV + portfolio and generates scoring across all 10 dimensions.

3

Generate report.

Markdown with 6 blocks: executive summary, CV match, level, compensation, personalization, and interview probability.

4

Generate PDF.

HTML template + keyword injection + adaptive framing. Puppeteer renders to PDF.

5

Register tracker.

TSV with company, role, score, grade, URL. Auto-merge via Node.js script.

6

Dedup.

Checks scan-history.tsv and applications.md. Zero re-evaluations.

Demo: auto-pipeline evaluating the Datadog Staff AI Builder offer in real time

Batch Processing

For high volume, batch mode launches a conductor that orchestrates parallel workers. Each worker is an independent Claude Code process with 200K context. The conductor manages the queue, tracks progress, and merges results.

200K

Context/worker

2x

Retries per failure

Fault-tolerant: a worker failure never blocks the rest. Lock file prevents double execution. Batch is resumable — reads state and skips completed items.

AI Resume Builder — Personalized#

A generic CV loses. Career-Ops works as an AI resume builder that generates a different ATS-optimized resume for each offer, injecting JD keywords and reordering experience by relevance. Not a template: a resume built from real CV proof points.

1

Extract 15-20 keywords from the JD.

Keywords land in the summary, first bullet of each role, and skills section.

2

Detect language.

English JD generates English CV.

3

Detect region.

US company generates Letter format. Europe generates A4.

4

Detect archetype.

Target archetypes map to AI Developer, Autonomous Systems, and Embedded/Robotics. The summary shifts based on the profile.

5

Select projects.

Top 3-4 by relevance. Hermes (or the OpenClaw→Hermes migration) for agent/AI roles. Cloud Infrastructure for platform/infra roles. AV experience for robotics/embedded.

6

Reorder bullets.

The most relevant experience moves up. The rest moves down — nothing disappears.

7

Render PDF.

Puppeteer converts HTML to PDF. Self-hosted fonts, single-column ATS-safe.

Personalized CV for Wave: rewritten summary, competencies adapted to Voice AI + Multi-Agent, bullets reordered by relevance
ATS-optimized CV
Cover letter for Wave: gradient header, Jacobo as voice + WhatsApp proof point, links to case studies and dashboard
Personalized cover letter

Target Archetypes

ArchetypePrimary Proof Point
AI DeveloperHermes (multi-agent AI team, Ollama Cloud model selection)
Autonomous SystemsCloud Infrastructure (Docker, CI/CD, monitoring pipelines) + AV background
Embedded / RoboticsGoogle Self-Driving Car Project + Pronto.ai (10 years AV systems)
Full-Stack AIThe Skate Workshop (React Native) + DALL-E Image Generator
Automation BuilderHermes (or the OpenClaw→Hermes migration) + Whisper Walkie (end-to-end AI-powered tooling)

Same CV. Multiple framings. All real — keywords get reformulated, never fabricated.

Before and After#

DimensionManualCareer-Ops
EvaluationRead JD, mental mapping10D automated scoring, A-F grade
CVGeneric PDFPersonalized PDF, ATS-optimized
ApplicationManual formPlaywright auto-fill
TrackingSpreadsheet or nothingTSV + automated dedup
DiscoveryLinkedIn alertsScanner: job boards + target company careers pages
BatchOne at a timeParallel URL processing
DedupHuman memoryURLs deduplicated automatically

Results#

The system is in active production use. Career-Ops handles the analytical heavy lifting — evaluating offers, generating tailored resumes, and tracking applications — so I can focus on the roles that actually fit.

12

Operational modes

10

Scoring dimensions

3

Career tracks targeted

0

Fabricated credentials

Stack

Claude Code

LLM agent: reasoning, evaluation, content generation

Playwright

Browser automation: portal scanning and form-filling

Puppeteer

PDF rendering from HTML templates

Node.js

Utility scripts: merge-tracker, cv-sync-check, generate-pdf

tmux

Parallel sessions: conductor + workers in batch

Lessons#

1

Evaluate before you build

My first instinct was to build a job search tool from scratch. Instead, I spent a day evaluating existing solutions. Career-Ops already solved 90% of what I needed. Customizing the last 10% took hours, not weeks. That's the same decision I make on any team: build vs. adopt.

2

Understand the architecture before you customize

I read the entire codebase before changing a line. Understanding the mode system, data contract, and scoring pipeline meant my customizations worked with the design — not against it. Same principle as joining any existing codebase.

3

Configuration is underrated engineering

Defining the right archetypes, scoring weights, portal queries, and CV proof points is the real work. The tool is powerful, but it's only as good as the configuration driving it. Garbage in, garbage out — same as Terraform, K8s, or any IaC.

4

Automate analysis, not decisions

Career-Ops evaluates offers. I decide which ones get my time. HITL is not a limitation — it is the design. AI filters noise, humans provide judgment.

5

Open source compounds

Every improvement santifer ships, I get for free. Every customization I make feeds back into my workflow immediately. That compound effect is why OSS adoption beats building in-house for most problems.

6

The best tool is the one you actually use

I run Career-Ops daily. It's not a demo or a proof of concept — it's my actual job search infrastructure. The test of any tool adoption is whether it becomes part of your real workflow.

FAQ#

Is this gaming the system?

Career-Ops automates analysis, not decisions. Every evaluation report is reviewed before I decide whether to apply. Every generated PDF is inspected to verify that keywords are reformulated from real experience, not fabricated. The apply mode fills form fields but stops before clicking submit — I make the final call on every application. This is the same HITL philosophy behind any CRM or applicant tracking system: the tool organizes, filters, and prepares, but a human provides the judgment. The system explicitly discourages applying to roles scoring below 4.0 out of 5, recommending against wasting both my time and the recruiter's time on poor-fit applications. Quality over quantity is a design principle, not a slogan.

Why Claude Code and not a script pipeline?

A script pipeline follows fixed rules — it cannot reason about context, weigh ambiguous signals, or generate narrative analysis. Career-Ops uses Claude Code as an LLM agent that reads the full job description, cross-references it against my CV and project proof points, and produces a 10-dimension evaluation with contextual reasoning for each score. It detects when a role title says Senior but the responsibilities suggest Staff level. It recognizes when a startup listing compensation as competitive likely means below market. It reformulates keywords from my real experience to match the JD vocabulary without fabricating skills I do not have. The output is a narrative evaluation report with specific rationale per dimension, not a template with blanks filled in. That reasoning capability is why an LLM agent outperforms any deterministic script for this task.

What does it cost to run?

Zero marginal cost per evaluation. Career-Ops runs on a Claude Max subscription, which covers all Claude Code usage across every project: portfolio development, OpenClaw development, and Career-Ops itself. Each evaluation uses approximately 4,000-6,000 input tokens for the JD plus CV context and generates around 2,000 tokens of evaluation output. Under the Max plan, this volume is well within the included capacity. There is no per-API-call billing, no token metering, and no usage caps that would throttle batch processing. The economics make it viable to evaluate every offer the scanner finds rather than pre-filtering manually.

Does the apply mode fill forms automatically?

The apply mode uses Playwright to navigate to the application form, take a snapshot of all visible fields, and read the page structure including labels, placeholders, and required field indicators. It then retrieves the cached evaluation report for that company and role, which contains the 10-dimension scoring, matched proof points, and relevant keywords. From this context, it generates coherent responses for each form field: cover letter text draws from the evaluation personalization section, the motivation question pulls from the company research, and skills questions reference the specific proof points that scored highest in the CV match dimension. Every generated response is displayed for my review before any field is filled. I approve, edit, or reject each answer individually. The submit button is never clicked by the system — that is always my action.

What happens when the scanner finds a duplicate?

The dedup system works in two layers. First, scan-history.tsv stores every URL the scanner has ever seen with a timestamp and source portal. Each new URL is checked against this file using exact string matching after normalization (stripping tracking parameters, trailing slashes, and query strings). Second, even if the URL is new, Career-Ops performs a fuzzy match against applications.md using a normalized company name plus role title comparison. This catches the common case where the same job is posted on multiple portals with different URLs. The company name is lowercased and stripped of suffixes like Inc or GmbH, and the role title is compared after removing seniority prefixes. If both layers pass, the offer enters the pipeline. If either catches a match, it is silently skipped. The result: zero duplicate evaluations.

Is it replicable?

Yes. Career-Ops is open source on GitHub, created by santifer. You need Claude Code with Playwright browser access enabled for portal scanning and form filling, plus a structured working directory following the data contract: cv.md as the canonical resume, a profile configuration file with your target roles and salary range, and a portals configuration listing the job boards and company career pages to scan. Each of the 12 operational modes is defined as a Claude Code skill file with its own context window, rules, and tool permissions. Fork the repository and customize the scoring dimensions, archetypes, and evaluation criteria for your own career profile. The onboarding flow walks you through setup step by step. That is exactly what I did — forked it, customized the profile for my AI Developer and Autonomous Systems targets, and started using it.

Career-Ops is a tool I adopted and customized. These are systems I built from the ground up — each with its own case study, architecture, and metrics.

Ask

Open the chat and ask how I evaluated, customized, and operate Career-Ops. Or check out OpenClaw and The Skate Workshop — those are systems I built from scratch.