Career Ops Job Search

Career-Ops Job Search Pipeline

Skill by ara.so — Daily 2026 Skills collection.

Career-Ops turns Claude Code into a full job search command center. It evaluates offers with A-F scoring, generates ATS-optimized PDFs, scans 45+ company portals, and tracks everything in a single source of truth — all powered by Claude AI agents.

Installation

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

# 2. Install Node dependencies (for PDF generation via Playwright)
npm install
npx playwright install chromium

# 3. Configure your profile
cp config/profile.example.yml config/profile.yml
# Edit config/profile.yml with your name, target roles, location, comp range, etc.

# 4. Configure portal scanner
cp templates/portals.example.yml portals.yml
# Add/remove companies you want to track

# 5. Add your CV in Markdown
# Create cv.md in project root — this is what the AI reads to evaluate fit
cat > cv.md << 'EOF'
# Your Name

## Experience
...your CV content in markdown...
EOF

# 6. Build the Go dashboard (optional but recommended)
cd dashboard
go build -o career-dashboard .
cd ..

Prerequisites

• Node.js 18+ (for Playwright/PDF)
• Go 1.21+ (for dashboard TUI)
• Claude Code (claude CLI) with an active Anthropic API key

# Verify Claude Code is installed
claude --version

# Open career-ops in Claude Code
claude   # run from the career-ops directory

Core Commands

All commands run inside Claude Code as slash commands. Paste into the Claude Code session:

/career-ops                     → Show all available modes
/career-ops {job URL or JD}     → Full auto-pipeline: evaluate + PDF + tracker entry
/career-ops scan                → Scan pre-configured portals for new offers
/career-ops pdf                 → Generate ATS-optimized CV for last evaluated offer
/career-ops batch               → Batch evaluate multiple offers in parallel
/career-ops tracker             → View application pipeline status
/career-ops apply               → AI-assisted application form filling
/career-ops pipeline            → Process all pending URLs in queue
/career-ops contacto            → Generate LinkedIn outreach message
/career-ops deep                → Deep company research report
/career-ops training            → Evaluate a course or certification
/career-ops project             → Evaluate a portfolio project fit

Auto-detection shortcut

Just paste a raw job URL or job description text — career-ops detects it and runs the full pipeline automatically:

https://boards.greenhouse.io/anthropic/jobs/12345

# Or paste the full JD text — Claude auto-routes it

Configuration Files

config/profile.yml

This is your candidate profile. Claude reads this for every evaluation.

# config/profile.yml
name: "Your Name"
title: "Head of Applied AI"
location: "Madrid, Spain"
timezone: "CET"
remote_preference: "remote-first"

target_roles:
  - "Head of AI"
  - "AI Engineer"
  - "LLMOps Engineer"
  - "Solutions Architect (AI)"

compensation:
  currency: "EUR"
  minimum: 120000
  target: 150000
  equity: true

languages:
  - "English (C2)"
  - "Spanish (Native)"

archetypes:
  - "LLMOps"
  - "Agentic"
  - "PM-AI"
  - "Solutions Architect"

portals.yml

Configure which company job boards to scan:

# portals.yml (copied from templates/portals.example.yml)
companies:
  - name: "Anthropic"
    url: "https://www.anthropic.com/careers"
    board: "greenhouse"
    
  - name: "ElevenLabs"
    url: "https://elevenlabs.io/careers"
    board: "ashby"
    
  - name: "n8n"
    url: "https://n8n.io/careers"
    board: "custom"

job_boards:
  ashby:
    base_url: "https://jobs.ashbyhq.com"
  greenhouse:
    base_url: "https://boards.greenhouse.io"
  lever:
    base_url: "https://jobs.lever.co"

search_queries:
  - "AI engineer remote"
  - "LLMOps"
  - "Head of AI Europe"

templates/states.yml

Canonical pipeline statuses (edit to match your workflow):

# templates/states.yml
statuses:
  - id: "pending"
    label: "Pending Review"
  - id: "evaluating"
    label: "Under Evaluation"
  - id: "applied"
    label: "Applied"
  - id: "screening"
    label: "HR Screening"
  - id: "interview"
    label: "Interviewing"
  - id: "offer"
    label: "Offer Received"
  - id: "rejected"
    label: "Rejected"
  - id: "withdrawn"
    label: "Withdrawn"

Modes Directory

Each file in modes/ is a Claude skill that defines behavior for one command:

modes/
├── _shared.md      # Shared context injected into every mode — customize this first
├── oferta.md       # /career-ops {JD} — full evaluation pipeline
├── pdf.md          # /career-ops pdf — PDF CV generation
├── scan.md         # /career-ops scan — portal scanner
├── batch.md        # /career-ops batch — parallel evaluation
├── tracker.md      # /career-ops tracker — pipeline viewer
├── apply.md        # /career-ops apply — form filling
├── pipeline.md     # /career-ops pipeline — process queue
├── contacto.md     # /career-ops contacto — LinkedIn outreach
├── deep.md         # /career-ops deep — company research
├── training.md     # /career-ops training — cert evaluation
└── project.md      # /career-ops project — portfolio project fit

Customizing modes via Claude

Ask Claude to modify the system from within Claude Code:

# In your Claude Code session:
"Change the archetypes in _shared.md to focus on backend engineering roles"
"Translate all modes to English"
"Add Mistral and Cohere to portals.yml"
"Update the scoring weights in oferta.md to weight compensation at 20%"
"Add a new mode called 'referral' for tracking employee referrals"

Go Dashboard TUI

The terminal dashboard provides a visual pipeline browser with filtering and sorting.

Building and running

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

Dashboard features

• 6 filter tabs: All, Pending, Applied, Interviewing, Offer, Rejected
• 4 sort modes: Date, Score, Company, Status
• Grouped/flat view: Toggle between company groups and flat list
• Lazy-loaded previews: Press Enter to read the full evaluation report
• Inline status changes: Update status without leaving the TUI

Go module structure

// dashboard/main.go — entry point
package main

import (
    tea "github.com/charmbracelet/bubbletea"
    "github.com/charmbracelet/lipgloss"
)

func main() {
    p := tea.NewProgram(initialModel(), tea.WithAltScreen())
    if _, err := p.Run(); err != nil {
        log.Fatal(err)
    }
}

// dashboard/model.go — core data model
package main

import "time"

type Application struct {
    ID          string    `json:"id"`
    Company     string    `json:"company"`
    Role        string    `json:"role"`
    Score       string    `json:"score"` // A, B+, B, C, D, F
    Status      string    `json:"status"`
    URL         string    `json:"url"`
    ReportPath  string    `json:"report_path"`
    PDFPath     string    `json:"pdf_path"`
    CreatedAt   time.Time `json:"created_at"`
    UpdatedAt   time.Time `json:"updated_at"`
    Archetype   string    `json:"archetype"` // LLMOps, Agentic, PM, SA...
    CompRange   string    `json:"comp_range"`
    Notes       string    `json:"notes"`
}

type Model struct {
    applications []Application
    filtered     []Application
    cursor       int
    activeTab    int
    sortMode     int
    grouped      bool
    preview      string
    showPreview  bool
    width        int
    height       int
}

Reading pipeline data from TSV

// dashboard/data.go
package main

import (
    "encoding/csv"
    "os"
    "path/filepath"
)

func loadApplications(dataDir string) ([]Application, error) {
    tsvPath := filepath.Join(dataDir, "pipeline.tsv")
    f, err := os.Open(tsvPath)
    if err != nil {
        return nil, err
    }
    defer f.Close()

    r := csv.NewReader(f)
    r.Comma = '\t'