When Santiago Fernández de Valderrama stopped applying for jobs and started building a system to do it for him, most people assumed it was a side project that would never ship. Eleven weeks later, he had evaluated 631 job listings, generated 354 personalized resumes, secured a role as Head of Applied AI, and open-sourced the entire system. In one week on GitHub it collected 35,000 stars. The total is now over 47,000.
Career-Ops is the most sophisticated career-focused skill bundle ever built on Claude Code. It is also a masterclass in how multi-mode skill architecture actually works at scale. This walkthrough goes inside the system: the file structure, the skill modes, the evaluation methodology, and how you can adapt it for your own job search regardless of your technical specialty.
What Is Career-Ops (and Who Made It)
Career-Ops is an open-source, AI-powered job search system built on top of Claude Code. The core repository lives at github.com/santifer/career-ops. The companion documentation and community hub are at career-ops.org.
Santiago Fernández de Valderrama spent 16 years founding, building, and eventually selling a phone repair business. When he entered the AI job market in 2025 he had deep applied AI experience but was starting from scratch as a job seeker. The process was manual, repetitive, and slow. “Week one of my AI job search was all manual. By week two I had stopped applying — I was building Career-Ops.”
The key design insight was treating the job search as an engineering problem. Every step — discovering postings, evaluating fit, tailoring a resume, tracking applications — is structured, repeatable, and can be described precisely enough for an AI to handle. He was not trying to get Claude to do something vague. He was writing very precise context files that told Claude exactly what kind of agent to be.
The result is a 14-mode multi-agent system where Claude Code reasons about offers, generates documents, navigates the web, and manages a structured pipeline of everything in progress. The human remains in the loop at every decision point. The machine handles the volume.
The Problem Career-Ops Solves
The average software engineer or ML researcher applying for senior roles in 2026 faces a structural problem: the volume of relevant postings is high, but meaningful evaluation of each one takes time.
Reading a job description carefully, checking whether it actually matches your experience, calibrating whether the company is worth your time, customizing your resume to surface relevant work — done properly, this takes 45 to 90 minutes per application. At 10 applications per week that is a part-time job on top of your actual job. At 50 applications it is unsustainable.
The standard workarounds create new problems. Sending a generic resume to everything tanks your reply rate and wastes everyone’s time. Using a rigid template for “tailoring” produces resumes that look tailored but are not. Relying on keyword matching to filter postings misses the signal that actually predicts fit.
Career-Ops solves this by doing the cognitive work that does not require human judgment: extracting job requirements, scoring fit across multiple dimensions, reorganizing your existing proof points to surface what is relevant, and structuring a document that will parse correctly through ATS systems. The human reviews the output and makes decisions. The machine handles the throughput.
Santiago’s numbers validate the approach: 631 evaluations led to 66 applications, which led to 12 interview processes, which led to an accepted offer. A 10% application rate from evaluations is not inefficiency — it is precision. Most of those 631 postings were genuinely not a good match, and submitting to them would have wasted both parties’ time.
Architecture Overview
Career-Ops is not a single script. It is a multi-mode agentic system where each mode is a Claude Code skill file with isolated context, its own behavioral instructions, and sometimes its own tool access.
The high-level structure:
career-ops/
├── AGENTS.md # Canonical agent instructions
├── CLAUDE.md # Claude Code entry point
├── cv.md # Your CV (the single source of truth)
├── article-digest.md # Optional proof points / portfolio details
├── config/
│ └── profile.example.yml # User configuration template
├── modes/ # All skill mode files
│ ├── _shared.md # Injected into every mode
│ ├── _profile.template.md # Profile customization template
│ ├── oferta.md # Single offer evaluation
│ ├── ofertas.md # Multi-offer comparison
│ ├── pdf.md # ATS resume generation
│ ├── scan.md # Portal scanner
│ ├── batch.md # Parallel batch processing
│ ├── auto-pipeline.md # End-to-end pipeline
│ ├── apply.md # Form automation
│ ├── tracker.md # Application status
│ ├── contacto.md # LinkedIn outreach
│ ├── deep.md # Company research
│ ├── interview-prep.md # Interview preparation
│ ├── training.md # Course/cert evaluation
│ ├── project.md # Portfolio project fit
│ ├── followup.md # Follow-up messaging
│ ├── update.md # Self-update mechanism
│ └── de/ fr/ ja/ pt/ ru/ tr/ # Localized mode variants
├── templates/ # CV HTML template, portal configs
├── batch/ # Conductor/worker scripts
├── dashboard/ # Go TUI application
├── data/ # Pipeline data (gitignored)
└── reports/ # Generated evaluationsThe key architectural decision is the separation between cv.md / config/profile.yml (your data, never overwritten by system updates) and modes/ (system logic, updated by the author). This means you can git pull to get the latest modes without losing your personalization.
The modes/_shared.md file is the common context layer. It is injected at the start of every mode, establishing the agent’s identity, core constraints, and access to your profile data. You do not edit _shared.md directly — instead, you populate your profile through config/profile.yml and the profile template.
Claude Code reads CLAUDE.md on launch, which delegates to AGENTS.md for the full system specification. This is a common pattern for keeping CLAUDE.md lean while maintaining detailed instructions in a file that other AI tools can also read.
File-by-File Breakdown
_shared.md — The Shared Context Layer
Every mode inherits _shared.md. This file does several things:
It establishes the agent’s role and constraints. The most important constraint: “NEVER submit an application without the user reviewing it first.” This is enforced at the instruction level, not just as a UI guardrail.
It loads your profile. The shared context references config/profile.yml (your target roles, narrative, proof points) and cv.md (your actual experience record). Every mode that evaluates or generates content has access to both.
It defines the data integrity rules. System files cannot be modified for user-specific content. User files cannot be overwritten by mode updates. This separation is what makes the system maintainable over a long job search.
It configures the learning loop. After every evaluation, the agent is instructed to update its understanding in the configuration files based on your feedback. Over time, the scoring becomes calibrated to your actual preferences, not just the default rubric.
oferta.md — Single Offer Evaluation
This is the core mode. When you paste a job URL or description, oferta.md runs a multi-step analysis:
Step 1: Legitimacy verification. Playwright navigates to the posting to confirm it is still active. This is a hard requirement — the system explicitly forbids using WebSearch for this check, because search results can be stale.
Step 2: JD parsing. The agent extracts role title, company, location, seniority signals, technical requirements, and soft requirements. Compensation is extracted if disclosed.
Step 3: Archetype detection. Career-Ops defines 6 role archetypes for AI/ML roles: AI Platform Engineer, Agentic Workflows Specialist, Technical AI PM, Solutions Architect, AI Field/Developer Engineer (FDE), and Transformation Lead. The archetype determines which aspects of your experience get weighted most heavily.
Step 4: Multi-dimensional scoring. Offers are scored across 6 categorical dimensions with weighted sub-axes:
- Role match and skills alignment (this is a gate-pass criterion — low scores here can terminate evaluation)
- Seniority and negotiability signals
- Compensation vs. your target market rate
- Geographic feasibility
- Company stage fit
- Interview likelihood given your profile
The output is a numeric score from 1–5 and a letter grade A through F.
Step 5: Tracker entry. The evaluation is written to the local data store with a structured record: URL, company, role, score, grade, evaluation date, and status.
pdf.md — ATS Resume Generation
The PDF mode is where the system earns its keep for most users. It does not fill in a template — it reasons about your CV and the job description together to produce a targeted document.
The process has seven distinct steps:
- Extract 15–20 keywords from the JD, prioritizing terms that appear in context rather than generic skills
- Detect language and region (A4 vs. Letter format, regional conventions)
- Confirm or re-detect the role archetype
- Select the 3–4 projects from your CV most relevant to this specific role
- Reorder experience bullets within each role to lead with what is most relevant to this JD
- Inject keywords into the professional summary and skills section without fabricating claims
- Render via Puppeteer with ATS-safe formatting (no tables, no columns, no graphics that OCR will mangle)
The constraint “without fabricating experience” is enforced throughout. The system reorganizes and reframes your existing proof points. It does not invent accomplishments.
Across Santiago’s 631 evaluations, this mode generated 354 personalized PDFs — a rate of about one PDF per 1.8 evaluations, meaning roughly half of evaluated offers cleared his quality threshold.
scan.md — Portal Scanner
Rather than searching job boards, scan.md goes directly to company career pages. The system ships with pre-configured entries for 45+ companies, covering:
- AI labs: Anthropic, OpenAI, Mistral, Cohere
- Voice AI: ElevenLabs, PolyAI, Deepgram, Vapi
- Developer platforms: Retool, Airtable, Vercel, Temporal
- ATS-backed portals: Greenhouse, Ashby, Lever, Wellfound
For each company in your portals.yml, Playwright loads the career page, applies your title_filter.positive keywords, and extracts matching postings. New URLs are added to the pipeline queue without duplicates.
You extend it by adding entries to portals.yml:
portals:
- name: "Databricks"
url: "https://www.databricks.com/company/careers/open-positions"
type: "greenhouse"
title_filter:
positive: ["ML", "AI", "machine learning", "applied scientist"]
negative: ["intern", "sales", "marketing"]The type field tells the scanner which DOM patterns to use for extraction. Greenhouse, Ashby, and Lever each have distinct structures. Custom entries default to a general extractor.
batch.md — Parallel Processing
When you have accumulated a queue of 10+ unprocessed URLs, batch.md runs them in parallel using a conductor/worker architecture.
The conductor splits the queue, launches multiple Claude Code subprocesses (one per worker), and monitors completion. Each worker evaluates its assigned URLs independently — each with its own 200K context window — then writes results back to the shared data store. The conductor merges results and handles failures.
Santiago ran 122 URLs simultaneously at peak. The efficiency gain is substantial: what would take 3+ hours serially completes in 20–30 minutes.
The deduplication system catches URLs that map to the same position through different paths: it uses exact URL matching plus a normalized company + role comparison. Santiago deduplicated 680 URLs over his search with zero re-evaluations on duplicates.
interview-prep.md — Interview Preparation
Once an application advances to the interview stage, interview-prep.md generates preparation material based on both the evaluated offer record and your CV.
The mode uses STAR + Reflection format for behavioral questions (Situation, Task, Action, Result, plus what you would do differently). For each likely question type, it maps specific experiences from your CV to the expected competency being tested.
For technical interviews, it identifies the most likely technical assessment areas based on the role archetype and company profile, then suggests which projects from your portfolio to discuss and why.
The output is a structured prep document, not a script. The goal is surfacing your own experience in a form that is ready to articulate, not memorizing pre-written answers.
contacto.md — Outreach and Networking
contacto.md handles LinkedIn outreach for roles where cold contact could accelerate the process. Given a target company and role, it:
- Identifies the most relevant contact (engineering manager, team lead, or hiring manager if discoverable)
- Researches the contact’s background for genuine personalization points
- Drafts a short, specific message that references a concrete connection between your background and their work
- Suggests a follow-up timing and framing
The constraint here is quality over volume. The system strongly discourages generic outreach. A message that does not reference something specific about the recipient’s work is worse than no message.
Installation Walkthrough
The full setup takes about 20 minutes.
Step 1: Prerequisites
You need Claude Code installed and configured, Node.js 18 or later, and optionally Go 1.21+ if you want the terminal dashboard.
Step 2: Clone and install dependencies
git clone https://github.com/santifer/career-ops.git
cd career-ops
npm install
npx playwright install chromiumPlaywright is required for the portal scanner and offer verification. The Chromium installation takes a few minutes.
Step 3: Run the doctor script
npm run doctorThis checks your environment: Node version, Playwright installation, Claude Code connectivity. Fix any issues it flags before proceeding.
Step 4: Configure your profile
cp config/profile.example.yml config/profile.ymlOpen profile.yml and fill in:
nameandemail— used in generated documentstarget_roles— a list of role titles you are targeting (used for portal scanning filters and archetype selection)narrative— a 2–3 sentence professional summary in first personproof_points— 5–8 accomplishments with concrete metricstarget_compensation— your range, used for compensation scoringgeography— your location and willingness to relocate
Step 5: Create your CV
Create cv.md in the project root. This is your master CV in Markdown format. Structure it with clear sections: Professional Summary, Experience (with role, company, dates, and bullet points), Skills, and Education.
The quality of your cv.md is the single largest factor in output quality. Be specific with metrics, use active verbs, and include technical stack details. The PDF mode selects and reorders from this file — it cannot invent content that is not here.
Optional: create article-digest.md with deeper detail on your most significant projects. This gives the PDF mode richer material to draw from for senior roles.
Step 6: Configure portals
cp templates/portals.example.yml portals.ymlEdit portals.yml to update title_filter.positive with your target role keywords and add any companies you want to monitor that are not in the default list.
Step 7: Verify integrity
node cv-sync-check.mjs
node verify-pipeline.mjsThese scripts confirm your CV and pipeline data are consistent. Run them after any significant changes to cv.md.
Step 8: Launch
Open Claude Code in the career-ops directory:
claudeClaude will read CLAUDE.md and load the system. Type /career-ops to see available commands. You are ready.
The Career-Ops Workflow in Action
Here is what a typical session looks like after initial setup.
Morning: Discovery run
/career-ops scanCareer-Ops loads Playwright, navigates to each portal in your portals.yml, filters for matching titles, and adds new URLs to data/pipeline.tsv. The scan takes 8–15 minutes depending on how many portals you have configured. When it finishes, you see a summary: “Found 7 new postings. 2 duplicate URLs skipped. Pipeline now has 23 pending.”
Batch evaluation
With a queue of 23 unprocessed postings:
/career-ops batchThe conductor launches workers. Each worker evaluates a subset of the queue: loads the posting via Playwright to confirm it is live, parses the JD, scores it against your profile, and writes a structured report to reports/. The full batch takes 20–30 minutes.
When it completes, you open the dashboard (./dashboard/career-dashboard --path ..) and browse the results by grade. You see something like: 2 A-grades, 5 B-grades, 11 C-grades, 5 D/F grades.
Deep evaluation and PDF generation
You open one of the A-grade evaluations and read the report. It confirms your instinct — good match, interesting company, compensation in range. You decide to apply.
/career-ops pdfCareer-Ops runs the PDF mode against this specific posting. It takes about 4 minutes: keyword extraction, archetype confirmation, project selection, bullet reordering, PDF rendering. The output is a file in reports/ with the company and role in the filename.
You open the PDF and review it. The summary accurately reflects your background. The selected projects are the right ones. The keyword density feels natural, not stuffed. You make two edits directly in the PDF, update the corresponding entry in data/tracker.tsv to “applied”, and submit the application yourself.
The system evaluated. You decided. The human is in the loop.
Follow-up tracking
A week later you check status:
/career-ops trackerThe dashboard shows your pipeline: applied, in progress, rejected, on hold. You update statuses based on responses received. followup.md generates a check-in message for an application that has gone 10 days without a response.
Customizing for Your Industry
Career-Ops ships with archetypes and scoring weights designed for AI/ML roles. If you are in a different technical area, the customization required is primarily in two files: config/profile.yml and the archetype definitions in modes/_shared.md.
Frontend engineers
Change target_roles to frontend-specific titles (Staff Frontend Engineer, Principal UI/UX Engineer, Frontend Platform Lead). The scoring dimensions remain largely valid, but the skills alignment section needs to weight frontend stack match (React, Next.js, performance metrics) appropriately. Update the proof_points in your profile to emphasize user-facing impact metrics: load time improvements, conversion lifts, component library adoption.
Backend and platform engineers
The default archetype system includes Solutions Architect, which maps reasonably to senior backend and infrastructure roles. Supplement with custom archetype definitions in _shared.md for roles like Staff SRE, Principal Platform Engineer, or Engineering Manager. The key dimensions to tune: systems design scope, scale indicators (RPS, data volume, team size), and on-call/reliability experience.
Data scientists and analysts
Add a Data Science archetype with evaluation dimensions weighted toward: statistical methodology rigor, domain expertise match, tooling stack (SQL, Python, R, Spark), and business impact framing. Data science role descriptions vary wildly in what they actually require — the archetype detection helps surface whether a “data scientist” role is really a PM, an analyst, or a research position.
Engineering managers
Scoring for EM roles needs different dimensions: team size and scope, people management breadth, technical credibility signals, cross-functional influence, and hiring/org building experience. The PDF mode still works well — reorganizing your experience to lead with leadership impact rather than individual technical contributions.
To add a new archetype, add a section to modes/_shared.md:
## Archetype: Engineering Manager
**Signals:** "team lead", "manage engineers", "people manager", "director of engineering"
**CV weighting:**
- Lead with team size and scope in role summaries
- Emphasize cross-functional projects and stakeholder management
- Highlight hiring and org building accomplishments
- Technical depth: sufficient but not primary signal
**Scoring adjustment:**
- Company stage fit weight: 1.5x (EM roles are more stage-sensitive)
- Skills alignment: focus on leadership competencies, not just technical stackThe agent will respect this archetype definition in both evaluation and PDF generation.
Career-Ops vs Building Your Own Career Skills
Career-Ops is comprehensive but opinionated. Before adopting it wholesale, it is worth understanding where it fits relative to building your own skills from scratch.
Where Career-Ops wins unconditionally:
The infrastructure is already built. Portal scanning with Playwright, ATS-optimized PDF rendering, deduplication logic, batch orchestration — these took weeks to develop and debug. If your goal is to run a serious job search, not to learn how to build job search tooling, start with Career-Ops.
The evaluation methodology is validated. Santiago’s rubric emerged from 631 real evaluations and calibration against actual hiring outcomes. A scoring system you design from scratch will have blind spots it takes months of real data to discover.
The community is active. 3,300+ members in the Discord, active issue tracker, regular updates. When a major ATS changes its DOM structure and breaks the scanner, it gets fixed quickly.
Where building your own makes sense:
Your career is in a domain with very different evaluation signals. A clinical research scientist, an investment banker, and a game developer have different hiring processes, different resume conventions, and different portal ecosystems. Career-Ops will require substantial rearchitecting for any of these.
You want to understand the system deeply enough to extend it. Building a simpler version first — a single-mode evaluator, just the PDF generation, just the portal scanner — teaches you patterns you will apply more effectively when you do adopt the full system.
You want skills that work in your existing Claude Code environment rather than a standalone project. Career-Ops is designed to run as its own project with its own CLAUDE.md. If you want career-related skills embedded in your normal development environment, a focused custom skill that reads your CV and evaluates postings is more appropriate.
The honest answer for most engineers in a serious job search: start with Career-Ops, customize the archetype definitions and portal list for your target domain, and build on top of the existing infrastructure rather than replacing it.
For skill design patterns you can apply beyond the job search context, the skills collection covers the range of what people are shipping in 2026.
Frequently Asked Questions
Does Career-Ops work for non-AI roles?
Yes, with customization. The default archetypes are AI/ML-focused, but the underlying architecture — multi-modal evaluation, ATS PDF generation, portal scanning — works for any technical role. You need to redefine the archetypes in _shared.md and update your portal list. Frontend and backend engineers have successfully adapted the system with 2–3 hours of configuration work.
How much does it cost to run?
Santiago ran his full job search on Claude’s Max plan at $200/month, which he was already using for other projects — so marginal cost was near zero. If you are running Career-Ops as your primary use of Claude Code, estimate roughly $30–80/month depending on volume, with batch processing being the largest cost driver. The system is also documented to work with Gemini CLI and other Claude Code-compatible tools.
Does it auto-submit applications?
No, and this is a hard constraint, not a soft default. The apply.md mode helps with form filling, but it stops before submission. Santiago’s design principle is explicit: AI filters and prepares, human decides and submits. Every PDF is reviewed before sending. This is not just ethical positioning — it is practical. An application sent without human review is one where you cannot handle a follow-up question you didn’t anticipate.
What happens when a portal changes its DOM structure?
The scanner breaks for that portal until it is updated. The portals.yml format includes a type field that maps to known ATS structures. When Greenhouse, Ashby, or Lever update their markup, the fix is a patch to the portal extraction logic. Custom entries using the general extractor are more fragile. The community Discord usually has a report and patch within 24–48 hours for major ATS changes.
Can I run it on Windows?
The core evaluation and PDF modes work on Windows. The batch processing that uses tmux for parallel sessions requires either WSL2 or a modification to use a Windows-native parallelization approach. The Go dashboard builds cleanly on Windows. The setup documentation notes the WSL2 path for users who need full feature parity.
How do I keep my profile data private?
Career-Ops is local-first by design. Your cv.md, config/profile.yml, and data/ directory are all local files sent directly to your configured AI provider. The project does not phone home. data/ is gitignored by default, so a git push to a public fork will not expose your application history. If you use a third-party AI provider, their standard data handling policies apply.
How does it handle rejections and learn from them?
The learning loop in _shared.md instructs the agent to update configuration based on feedback after each evaluation. In practice, this means: when an application gets a response (positive or negative), you note the outcome in the tracker, and the system can identify patterns — companies or role types where your A-grades are not converting, for example. The rubric weights can be manually adjusted in _shared.md to reflect what you have learned. This calibration is one of the most valuable things you can do in week 2–3 of a job search.
Career-Ops represents what Claude Code skills look like when they are engineered seriously for a complex, real-world problem. The architecture patterns here — shared context injection, mode isolation, conductor/worker batch processing, HITL constraints at the instruction level — transfer directly to other complex workflow automation. The job search domain is just where these patterns got their most complete implementation.
The repository is at github.com/santifer/career-ops. The community is at career-ops.org.
For a broader look at what Claude Code skills can do, see the complete 2026 skills guide and our comparison of the top career-focused Claude Code systems.
If you are building your own skills, the skills authoring guide covers the patterns Career-Ops uses — shared context layers, mode isolation, and how to structure instructions Claude will follow reliably across hundreds of sessions.