Stop Applying Blindly! Career-Ops AI Agents Land Dream Jobs

Stop Applying Blindly! Career-Ops AI Agents Land Dream Jobs

The Brutal Truth About Modern Job Hunting

Let me guess: you're spending hours every week crafting cover letters that nobody reads, tweaking your CV for the hundredth time, and drowning in spreadsheet tabs tracking applications you'll never hear back from. Meanwhile, companies deploy AI to filter you out before a human ever sees your name. The game is rigged—and you've been playing with stone-age tools.

What if you could flip the script? What if, instead of being filtered, you had AI doing the filtering—evaluating hundreds of offers while you sleep, scoring them A-F across 10 weighted dimensions, and generating battle-tested CVs optimized to slip past those same ATS systems?

Enter Career-Ops—the open-source AI job search system that turned one developer's painful months of manual applications into 740+ evaluated listings, 100+ personalized CVs, and one Head of Applied AI role landed. Built on Claude Code with 14 specialized skill modes, a blazing-fast Go dashboard, and PDF generation that actually beats the bots.

This isn't spray-and-pray automation. This is precision-guided career warfare. And it's about to change everything.

What Is Career-Ops? The AI Command Center Developers Actually Need

Career-Ops is an AI-powered job search automation system built by Santiago Fernández, a Head of Applied AI who literally engineered the tool he wished existed during his own grueling job hunt. After months of manual applications, he did what any elite developer would do: he automated the entire pipeline.

The repository has exploded across developer communities for one simple reason: it works. Unlike generic job boards or basic Chrome extensions, Career-Ops transforms any AI coding CLI—Claude Code, Gemini CLI, or OpenCode—into a full job search command center. It doesn't just find jobs; it thinks about them, evaluating fit through genuine reasoning about your CV versus job descriptions (not crude keyword matching), then adapts your entire application strategy per listing.

Here's what makes it genuinely different: Career-Ops is agentic. Claude Code literally navigates career pages with Playwright, performs structured evaluations, generates ATS-optimized PDFs with injected keywords, and maintains a single source of truth for your entire pipeline. The system comes pre-loaded with 45+ company portals including Anthropic, OpenAI, ElevenLabs, Retool, and n8n—plus automated scanning across Ashby, Greenhouse, Lever, and Wellfound.

The philosophy? Companies use AI to filter candidates. Career-Ops gives candidates AI to choose companies. It's a filter, not a spam cannon. The system actively discourages applying to anything scoring below 4.0/5. Your time matters. Recruiters' time matters. This tool respects both.

Key Features That Separate Career-Ops From Everything Else

Auto-Pipeline: One URL, Full Evaluation

Paste any job URL and watch the magic happen. The system automatically classifies the role archetype (LLMOps, Agentic, PM, Solutions Architect, Forward Deployed Engineer, or Transformation), runs a 6-block evaluation, generates a tailored PDF, and logs everything to your tracker. No context switching. No copy-paste hell.

A-F Structured Scoring (10 Weighted Dimensions)

Forget gut feelings. Career-Ops scores every opportunity across 10 weighted dimensions with surgical precision: role summary, CV match analysis, level strategy, compensation research, personalization opportunities, and interview prep with STAR+R frameworks. Each evaluation produces a structured .md report you can actually use.

Interview Story Bank Accumulation

Here's the secret weapon most job seekers miss: behavioral interviews reward preparation, not improvisation. Career-Ops accumulates STAR+Reflection stories across every evaluation, building 5-10 master narratives that answer virtually any behavioral question. By evaluation #20, you'll have a repertoire most candidates never develop.

ATS-Optimized PDF Generation

The PDF engine uses Playwright/Puppeteer with HTML templates featuring Space Grotesk and DM Sans typography. More critically: it injects role-specific keywords directly into your CV, ensuring ATS systems flag you as a match without sacrificing human readability. Design meets deception—in the best way.

Portal Scanner with 45+ Pre-configured Companies

The scanner covers AI Labs (Anthropic, OpenAI, Mistral, Cohere, LangChain, Pinecone), Voice AI (ElevenLabs, PolyAI, Hume AI, Deepgram), Enterprise (Salesforce, Twilio, Gong), Automation (n8n, Zapier, Make.com), and European tech (Factorial, Attio, Travelperk). Add custom queries across 6 major job boards.

Batch Processing with Parallel Sub-agents

Evaluate 10+ offers simultaneously using claude -p workers. The batch system distributes evaluations across parallel processes, cutting what used to take hours into minutes. Perfect for Sunday evening pipeline reviews.

Go-Powered Dashboard TUI

Built with Bubble Tea and Lipgloss in Catppuccin Mocha theme, the terminal UI offers 6 filter tabs, 4 sort modes, grouped/flat views, and lazy-loaded previews. It's the kind of developer experience that makes you want to check your pipeline.

Human-in-the-Loop Integrity

The AI never submits applications. It evaluates, recommends, and prepares—but you always have final control. Automated merge, deduplication, status normalization, and health checks keep your data clean without removing human judgment.

Real-World Use Cases Where Career-Ops Dominates

Scenario 1: The Passive Candidate Staying Market-Aware

You're not desperate—you're strategic. You want to know what Head of AI roles actually pay, which companies are building genuine agentic systems versus AI-washing, and whether your current compensation is competitive. Career-Ops lets you scan weekly, evaluate 20 roles in 30 minutes, and build market intelligence without burning bridges. Knowledge is leverage in negotiation.

Scenario 2: The Targeted Transition (IC to Leadership)

Moving from Senior Engineer to Staff+ or Engineering Manager? The archetype detection automatically classifies roles by seniority trajectory. The level strategy block tells you whether a "Senior" title at a startup equals "Staff" at Big Tech. No more title inflation traps.

Scenario 3: The Geographic Arbitrage Seeker

Remote roles with SF salaries but Lisbon cost-of-living? The compensation research block includes geographic discount pushback frameworks—actual scripts for negotiating location-agnostic pay. The system flags companies with transparent pay bands versus those playing hide-the-salary.

Scenario 4: The Portfolio Builder Evaluating Side Opportunities

Not every role deserves a full application. Use /career-ops-project to evaluate whether a freelance gig or advisory position strengthens your narrative. Use /career-ops-training to assess if that $2,000 certification actually moves the needle. Opportunity cost is real—quantify it.

Scenario 5: The Post-Layoff Recovery Sprint

When you need to move fast without looking desperate, batch processing becomes your lifeline. Evaluate 50 roles, identify the 8 worth pursuing, generate tailored materials, and execute with precision. The tracker prevents embarrassing double-applications, and the story bank ensures every interview builds on the last.

Step-by-Step Installation & Setup Guide

Getting Career-Ops running takes under 10 minutes. Here's the complete flow:

Prerequisites

• Node.js 18+
• Claude Code, Gemini CLI, or OpenCode installed
• Go 1.21+ (for dashboard only)

Core Installation

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

# Install Node dependencies
npm install

# Install Playwright browser for PDF generation
npx playwright install chromium

Health Check

# Validate all prerequisites are met
npm run doctor

This verifies Node version, Playwright installation, CLI availability, and config file presence.

Configuration Setup

# Copy and customize your profile
cp config/profile.example.yml config/profile.yml

# Copy and customize portal scanning targets
cp templates/portals.example.yml portals.yml

Edit config/profile.yml with your details: target roles, compensation expectations, geographic preferences, skills matrix, and career narrative. This is the most critical step—the system learns you from this file.

Add Your CV

# Create cv.md in project root with your CV in markdown↗ Smart Converter
touch cv.md

Use markdown formatting for clean parsing. Include quantified achievements, not just responsibilities.

Personalize with Claude

# Open Claude Code in the project directory
claude

Then instruct Claude to adapt the system:

"Change the archetypes to backend engineering roles"
"Translate the modes to English"
"Add these 5 companies to portals.yml"
"Update my profile with this CV I'm pasting"

Critical insight: The system is designed to be customized by Claude itself. Modes, archetypes, scoring weights, negotiation scripts—just ask. Claude reads the same files it uses, so modifications are precise and contextual.

Dashboard Build (Optional)

cd dashboard
go build -o career-dashboard .
./career-dashboard --path ..

REAL Code Examples From the Repository

Example 1: Gemini CLI Native Integration

Career-Ops supports multiple AI providers. Here's the exact Gemini CLI setup from the README:

# Install Gemini CLI globally
npm install -g @google/gemini-cli

# Authenticate with your Google account (free, no billing required)
gemini auth

# Navigate to project and launch
cd career-ops
gemini

# Use all 15 slash commands natively
/career-ops "Senior AI Engineer at Anthropic..."
/career-ops-evaluate --file ./jds/openai.txt
/career-ops-scan
/career-ops-pdf
/career-ops-tracker

The GEMINI.md file auto-loads as context, and all commands are defined in .gemini/commands/*.toml. This isn't bolted-on support—it's first-class multi-CLI architecture. The same evaluation logic in modes/*.md powers every interface.

Why this matters: You're not locked into Anthropic. Switch providers based on rate limits, pricing, or personal preference. The system abstracts the AI layer while preserving evaluation quality.

Example 2: Standalone API Script (No CLI Required)

For CI/CD pipelines or environments where CLI installation isn't possible:

# Get free API key at https://aistudio.google.com/apikey
cp .env.example .env
# Edit .env → set GEMINI_API_KEY=your_key_here

# Install dependencies
npm install

# Evaluate job description directly
node gemini-eval.mjs "We are looking for a Senior AI Engineer..."

# Or evaluate from file
node gemini-eval.mjs --file ./jds/my-job.txt

# Or use npm script shorthand
npm run gemini:eval -- "JD text here"

Free tier limits: gemini-2.5-flash provides 15 requests per minute, 1 million tokens daily at zero cost. For heavy batch processing, this covers most individual users. The native CLI option uses Google OAuth with even fewer restrictions.

Example 3: Dashboard Compilation and Launch

The Go dashboard delivers a visual pipeline browser without leaving your terminal:

cd dashboard                    # Enter dashboard directory
go build -o career-dashboard .  # Compile to binary
./career-dashboard --path ..    # Launch with project root as data source

Architecture note: The dashboard uses Bubble Tea for the Elm-inspired TUI framework, Lipgloss for styling, and implements lazy-loaded previews for performance with large datasets. The --path flag lets you run the dashboard from anywhere while pointing at your active career-ops instance.

Pro tip: Add the compiled binary to your $PATH for global access:

mv career-dashboard /usr/local/bin/
career-dashboard --path ~/projects/career-ops

Example 4: Batch Processing Orchestration

For high-volume evaluation, the batch system distributes work across parallel Claude workers:

# The batch runner script coordinates parallel evaluation
# Found in: batch/batch-runner.sh

# Self-contained worker prompt ensures consistent evaluation
# Found in: batch/batch-prompt.md

The batch-prompt.md is deliberately self-contained—each worker receives complete context without depending on shared state. This eliminates race conditions and makes the system resilient to individual worker failures. The batch-runner.sh orchestrator handles queue distribution, result aggregation, and error retry logic.

Scaling insight: With claude -p parallelization, a typical user can process 10-15 complex evaluations in 3-5 minutes. The bottleneck becomes API rate limits, not system architecture.

Advanced Usage & Best Practices

Nurture the System Like a New Recruiter

The README is explicit: "The first evaluations won't be great." Career-Ops doesn't know your career story, your proof points, or your red lines. Invest 30 minutes feeding it context—paste past performance reviews, link to shipped projects, explain why you left roles. By evaluation #10, the quality jumps dramatically. By #50, it's uncanny.

Maintain Your Article-Digest.md

The optional article-digest.md file accumulates your public proof points: conference talks, blog posts, open-source contributions. The evaluation logic references this for credibility scoring. Most candidates underinvest here.

Customize Scoring Weights Per Search Phase

Early in a search, prioritize learning potential and trajectory over compensation. When evaluating competing offers, flip the weights. The config/profile.yml supports dynamic weight adjustments—use them.

Leverage the Negotiation Scripts Proactively

Don't wait for an offer. The salary negotiation frameworks include competing offer leverage scripts and geographic discount pushback templates. Study these before your first recruiter call. Preparation creates optionality.

Git-Track Your Config, Gitignore Your Data

The .gitignore already excludes data/, reports/, and output/. Commit your config/profile.yml and portals.yml to version your search strategy. This lets you A/B test different approaches across branches.

Career-Ops vs. Alternatives: Why This Wins

The verdict: Career-Ops occupies a unique position—more intelligent than job boards, more private than SaaS tools, more systematic than spreadsheets. For technical professionals who value control and precision, there's no genuine alternative.

Frequently Asked Questions

Is Career-Ops free to use?

Yes. The code is MIT-licensed. You'll need API access to Claude, Gemini, or OpenCode—Claude Code has a free tier; Gemini CLI and API are free with generous limits. The only potential cost is API usage at scale, which typically runs under $5/month for active job seekers.

Will this auto-submit applications without my approval?

Absolutely not. The system is explicitly designed with human-in-the-loop architecture. Default prompts instruct AI not to auto-submit, and the disclaimer emphasizes user control. Always review generated content before any submission.

Does this work for non-technical roles?

The archetype system is customizable. While pre-configured for AI/ML engineering, product, and solutions roles, you can instruct Claude to redefine archetypes for design, marketing, operations, or any other field. The evaluation framework is domain-agnostic.

How do I prevent getting banned from job portals?

Career-Ops includes rate limiting and respectful scanning patterns. The disclaimer requires compliance with third-party Terms of Service. Don't spam, don't overwhelm ATS systems, and respect robots.txt. This is a precision tool, not a denial-of-service weapon.

Can I use this if I'm not comfortable with command line tools?

Basic CLI familiarity is required. However, Claude Code and Gemini CLI provide conversational interfaces that abstract most complexity. If you can run npm install and edit text files, you can use Career-Ops. The dashboard TUI requires no CLI knowledge beyond launching it.

What makes the PDFs "ATS-optimized"?

The system injects role-specific keywords from job descriptions into your CV while maintaining clean typography. It uses standard fonts (Space Grotesk, DM Sans), avoids tables and columns that confuse parsers, and outputs clean HTML rendered through Playwright. Readable by humans, parseable by machines.

How is my personal data handled?

Everything stays local. Your CV, contact information, and evaluation data reside on your machine. Data is sent directly to your chosen AI provider (Anthropic, Google, etc.) with no intermediary. The project has no backend, no analytics, no data collection. You are the only one who sees your data.

Conclusion: Reclaim Your Job Search

The modern job market is asymmetric. Companies deploy sophisticated AI to filter thousands of candidates while expecting you to manually craft individual applications. That asymmetry ends now.

Career-Ops represents something rare in open-source tooling: a system built from genuine pain, battle-tested in production by its own creator, and refined through 740+ real evaluations and 100+ generated CVs. Santiago didn't build this for GitHub stars—he built it to land a Head of Applied AI role. Then he open-sourced it so you could do the same.

The philosophy is clear: quality over quantity, intelligence over automation, human judgment over algorithmic submission. This isn't about applying to more jobs. It's about identifying the right jobs and presenting yourself flawlessly for them.

Your move. The job market won't get less competitive. The AI arms race won't slow down. But with Career-Ops, you're no longer bringing a spreadsheet to a machine learning fight.

⭐ Star Career-Ops on GitHub and start your precision job search today. Your dream role is in that 740 somewhere—let's find it.

Got hired using Career-Ops? Share your story and join the growing community on Discord.