The people who came after me wrote down how they got hired.
Every card is a public issue you can open. Landed yours? Leave your card →
⭐ If career-ops helped you, a star helps the next person find it.
## Your turn
Paste one job you were about to apply to tonight. If it comes back do not apply, you just got the night back. If it comes back with a plan, you know what to do next.
```bash
npx @santifer/career-ops init
```
## You don't have to search alone
The silence after you hit send is not about you. Enough people saw the same thing to write the practice down, in six lines:
> Apply better to fewer. Signal over volume. Evidence over keywords. A human decides. Local-first. Dignity on both sides of the table.
Hiring will not fix itself. The people going through it can, and they are already in the room, comparing notes and fixing each other's setups. [This is where the fix gets written](https://github.com/career-ops-hq/career-ops/blob/HEAD/CONTRIBUTING.md). A room, not a club. **Let's build together.**
## Sponsors
career-ops is free for candidates, forever. These companies sponsor the project:
SerpApi · Build a portfolio project with live search data. SerpApi gives developers structured JSON/Markdown from Google Search, Maps, Shopping, and other engines through a simple API call.
> Sponsorship buys clearly labeled visibility, never influence: no amount of money changes the roadmap or places anything in the product. Sponsors never appear in evaluations, rankings or recommendations.
## What career-ops does for you
Paste a job. It tells you whether that night is worth it.
- **Still open?** It checks that the posting is still live before you write a word.
- **Not you?** It scores the role against your real CV and tells you to skip a weak fit. You can override it.
- **Worth it?** It drafts the CV, the cover letter and the answers. You read them. You send them.
- **Who do I talk to?** It finds the person and drafts the note. It never sends it.
- **Where does it all go?** Every application stays on your machine. Nothing is uploaded to us.
- **What should I learn?** After a run of noes, it names the gap.
The first runs are rough. It does not know you yet. Talk to it: your CV, what you want, what you refuse. Think of it as a recruiter's first week.
On first launch it asks for all that in chat. Nothing to configure by hand.
## What career-ops will not do
- **Auto-submit an application.** It drafts the answer to every field; you review and click Submit. The script never POSTs (`prepare-application.mjs`).
- **Send an email.** Drafts only. There is no mail transport anywhere in this codebase.
- **Phone home.** No telemetry, no backend of ours. Your CV goes from your machine to the AI provider you chose, and nowhere else. The only public ledger is this repo: `HIRED.md` and its issues.
- **Push you to apply below 4.0/5.** It will tell you not to. You can override it, and it will say so.
It reformulates your CV; it must never fabricate it. A check in code stops a PDF whose numbers or facts appear in neither your CV nor your article digest, but it cannot judge every rewording yet. Read every CV before you send it. Details in the [FAQ](#faq).
## Features
| Feature | Description |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **A-H Evaluation** | Role summary, CV match (with how much each requirement matters for this posting, and whether that weight came from the JD's own wording, its structure, or an estimate, labelled per requirement; an estimate can never be top-band), level strategy, comp research, personalization, interview prep (STAR+R) -- plus a Block G posting-legitimacy check (is it still open, is it a repost: observations, not verdicts), and a Work-Auth signal that flags an explicit no-sponsorship JD as a hard blocker |
| **Human-in-the-Loop** | AI evaluates and recommends, you decide and act. The system never submits an application -- you always have the final call |
| **ATS PDF Generation** | ATS-readable CVs tailored to each JD from your own experience, in Space Grotesk + DM Sans design |
| **Cover Letter Generator** | Research-backed cover letters with keyword mirroring, four interactive angle prompts (why/problems/approach/tone), draft-in-chat approval gate, and A4 PDF via the same HTML + Playwright pipeline as CVs. Auto-drafts on every evaluation; complete and generate on demand via `/career-ops cover` |
| **Beyond the CV** | Company research ([`deep`](modes/deep.md)) surfaces AI strategy, recent moves, engineering culture, and the angle your profile should take. Contact discovery ([`contacto`](modes/contacto.md)) identifies the hiring manager, recruiter, or team peer worth reaching out to and drafts a ≤300-character LinkedIn message tuned to each contact type. Formal application email drafts ([`email`](modes/email.md)) turn an evaluated report or pasted JD into a subject line, body, and attachment checklist without sending, submitting, or clicking anything. Applications get you in the queue; research gets you a conversation. |
| **Pattern Analysis** | Rejection patterns and per-ATS-channel advance rates (`analyze-patterns.mjs`), lifetime funnel stats (`stats.mjs`), repost detection, a possible sign of a ghost job (`detect-reposts.mjs`) |
Everything else it does
| Feature | Description |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **Auto-Pipeline** | Paste a URL, get a full evaluation + PDF + tracker entry |
| **Interview Story Bank** | Accumulates STAR+Reflection stories across evaluations -- 5-10 master stories you can adapt to the behavioral questions you get |
| **Negotiation Scripts** | Salary negotiation frameworks, geographic discount pushback, competing offer leverage |
| **Application Email Drafts** | Formal recruiter/referral/cold application emails from a report or pasted JD, with subject line, attachment checklist, source-backed fit points, and a profile-driven contact block. Draft-only -- career-ops never sends, submits, or clicks anything. |
| **Portal Scanner** | 100+ companies pre-configured (Anthropic, OpenAI, ElevenLabs, Retool, n8n...) + custom web-search queries across Ashby, Greenhouse, Lever, Wellfound |
| **Funded Company Discovery** | Review-first `company:funded` command surfaces recently funded companies and source diagnostics from structured public feeds without editing your data |
| **Batch Processing** | Parallel evaluation with headless CLI workers (`claude -p` / `opencode run`) |
| **Dashboard TUI** | Terminal UI to browse, filter, and sort your pipeline |
| **Pipeline Integrity** | Automated merge, dedup, status normalization, health checks |
| **Interview Suite** | Time-blocked prep plans, practice sessions with feedback, post-interview debriefs ([`interview/`](modes/interview/README.md)), and a company red-flag detector ([`interview-redflag`](modes/interview-redflag.md)) |
| **Offer Stage** | Contract reading companion -- clause walk plus a lawyer question list ([`offer-prep`](modes/offer-prep.md)) -- and a desired/advertised/actual salary-gap analyzer (`salary-gap.mjs`) |
| **Follow-ups & Replies** | Follow-up cadence calculator and seeded reminders (`followup-cadence.mjs`, `followup-seed.mjs`); turn them off with `follow_ups.enabled: false` in `config/profile.yml`; employer reply classification into tracker updates ([`reply-watch`](modes/reply-watch.md)) |
| **Plugin System** | Opt-in integrations (Gmail, Notion, Apify + a community registry), disabled by default -- see [docs/PLUGINS.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/PLUGINS.md) |
## Quick Start
**Fastest way, one command:**
```bash
npx @santifer/career-ops init
```
> 💡 `npx` ships with [Node.js](https://nodejs.org): it runs the installer once,
> without installing anything globally. No Node yet? Install it first.
> (Already using a Claude Code / Codex CLI? Then you already have it.)
This clones the latest release into `./career-ops` and installs dependencies. Then:
```bash
cd career-ops
claude # or codex / qwen / opencode / agy / grok — open your AI CLI here
```
**On first launch, career-ops walks you through setup (your CV, profile and target roles) just by chatting. Nothing to edit by hand.**
Prefer to set it up manually? (git clone)
```bash
git clone https://github.com/career-ops-hq/career-ops.git
cd career-ops && npm install
npx playwright install chromium # only needed for PDF generation
# On a non-Debian/Ubuntu Linux distro (Fedora, Arch, ...), Chromium's system
# libraries aren't installed by the line above — install them yourself with
# your distro's package manager if PDF generation fails to launch the browser
# (Playwright's own docs list the required libraries per platform).
# 2. Check setup
npm run doctor # Validates all prerequisites
# 3. Configure
cp config/profile.example.yml config/profile.yml # Edit with your details
cp templates/portals.example.yml portals.yml # Customize companies
# 4. Add your CV
# Create cv.md in the project root with your CV in markdown
# 5. Open your AI CLI in this directory
claude # or codex / opencode / qwen / agy / grok
# Then ask your CLI to adapt the system to you:
# "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"
# 6. Start using
# Paste a job URL or JD text to trigger auto-pipeline
# If your CLI supports slash commands, use /career-ops (or its CLI-specific alias)
# In Codex, ask for the same mode in plain language, e.g.:
# "Run the career-ops scan mode"
# "Run the career-ops pipeline mode for data/pipeline.md"
# "Run the career-ops pdf mode for the latest evaluated role"
# "Run the career-ops tracker mode and summarize the current statuses"
```
### Scanning through an outbound proxy
Node's ordinary `fetch()` may ignore `HTTP_PROXY`, `HTTPS_PROXY` and `NO_PROXY` in a proxy-only sandbox. Provider requests can use those variables with `CAREER_OPS_TRUST_PROXY_EGRESS=1 node scan.mjs`. This uses a request-scoped proxy dispatcher; unrelated requests are unaffected, and `NO_PROXY` destinations still use the local private-address guard.
Set this flag **only when the configured proxy itself blocks connections to private, loopback and metadata addresses**. When a proxy resolves the destination remotely, career-ops cannot verify that final address locally; the proxy must enforce that part of the SSRF boundary. Without this explicit trust setting, provider requests keep their normal direct transport and a DNS failure names the proxy setup needed. Proxy URLs containing credentials must use HTTPS; credential-free HTTP proxies remain supported. Existing installations keep direct transport after a system update; proxy environment variables alone do not enable it. Before enabling the flag, run `npm install` in the career-ops directory to install the added `undici` dependency. It is loaded only for an opted-in request with a configured proxy, so direct scanning continues to work even before that dependency is installed.
### Global install
```bash
npm i -g @santifer/career-ops
```
This installs the `career-ops` binary globally so you can run it directly instead of via `npx`. Unlike `npx @santifer/career-ops init` (which bootstraps a project directory), the global install gives you a persistent `career-ops` command available anywhere in your terminal.
**Which one should you use?**
- `npx @santifer/career-ops init`: best for first use; creates a dedicated project folder.
- `npm i -g @santifer/career-ops`: best once you have a project folder and want to run career-ops commands directly.
> **The system is designed to be customized by your AI coding CLI itself.** Modes, archetypes, scoring weights, negotiation scripts -- just ask it to change them. It reads the same files it uses, so it knows exactly what to edit.
See [docs/SETUP.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/SETUP.md) for the full setup guide, [docs/RUNNING_ON_A_BUDGET.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/RUNNING_ON_A_BUDGET.md) for instructions on running career-ops cheaply using custom or local models (and [docs/FREE_TIER.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/FREE_TIER.md) for running it at zero cost on Antigravity CLI's free tier), [docs/AUTOMATION.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/AUTOMATION.md) for scheduling recurring scans and a zero-token triage-to-shortlist recipe, [docs/KEEPING_PORTALS_LIVE.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/KEEPING_PORTALS_LIVE.md) for keeping your company list current, [docs/APPLY_AUTOFILL.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/APPLY_AUTOFILL.md) for details on the ATS auto-fill flow, [docs/LINKEDIN_JOIN.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/LINKEDIN_JOIN.md) for cross-referencing a LinkedIn connections export against the companies in your funnel, and [docs/FAQ.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/FAQ.md) for answers to common setup questions, including [how story provenance prevents invented numbers](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/FAQ.md#why-does-career-ops-refuse-to-use-a-number-from-my-story-bank). Design principles live in [ARCHITECTURE.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/ARCHITECTURE.md); runtime flows in [docs/ARCHITECTURE.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/ARCHITECTURE.md).
## Usage
career-ops uses a shared command router. In CLIs that register slash commands, it looks like this:
```
/career-ops → Show all available commands
/career-ops {JD} → AUTO-PIPELINE: evaluate + report + PDF + tracker (paste text or URL)
/career-ops pipeline → Process pending URLs from inbox (data/pipeline.md)
/career-ops oferta → Evaluation only, blocks A to H (no auto PDF)
/career-ops ofertas → Compare and rank multiple offers
/career-ops contacto → LinkedIn power move: find contacts + draft message
/career-ops deep → Deep research prompt about company
/career-ops interview-prep → Generate company-specific interview prep doc
/career-ops interview → Interactive profile/CV onboarding interview
/career-ops master-profile → Import, review, and validate your Master Career Profile
/career-ops eu-swe → Calibrate a European SWE application before CV/apply/interview
/career-ops interview/plan → Time-blocked prep plan for an upcoming interview
/career-ops interview/practice → Practice interview, one question at a time with feedback
/career-ops interview/debrief → Post-interview debrief: close gaps, predict next round
/career-ops interview-redflag → Analyze employer warning signs before joining a company
/career-ops pdf → PDF only, ATS-optimized CV
/career-ops text → Tailored markdown CV (mirrors cv.md, no PDF)
/career-ops latex → Export CV as LaTeX/Overleaf .tex
/career-ops latex-tex → Tailor your own resume.tex in place (opt-in; cv.md stays default)
/career-ops cover → Cover letter: standalone JD paste or /career-ops cover {slug}
/career-ops email → Formal application email draft (draft-only; never sends, submits, or clicks)
/career-ops add → Add a project/paper/role to your CV (fetch + preview + confirm)
/career-ops expand → Auto-discover and add missing competencies from profile links
/career-ops training → Evaluate course/cert against North Star
/career-ops project → Evaluate portfolio project idea
/career-ops tracker → Application status overview
/career-ops agent-inbox → Queue/drain requests for the next session (data/agent-inbox.md)
/career-ops apply → Live application assistant (reads form + generates answers)
/career-ops scan → Scan portals and discover new offers
/career-ops discover → Resolve a company list to scannable ATS boards + append to portals.yml (zero-token)
/career-ops batch → Batch processing with parallel workers
/career-ops patterns → Analyze rejection patterns and improve targeting
/career-ops offer-prep → Read a received offer/contract with the candidate: clause walk + lawyer questions (not legal advice)
/career-ops titles → Suggest adjacent job titles from your CV to broaden the search
/career-ops upskill → Aggregate skill-gap analysis from your evaluated reports
/career-ops followup → Follow-up cadence tracker: flag overdue, generate drafts
/career-ops reply-watch → Classify employer replies and suggest tracker updates
/career-ops outcome → Record application outcome & archive artifacts
/career-ops calibrate → Advisory report: do your evaluation scores predict your real outcomes? Reads /outcome data; never changes scoring
/career-ops update → Update career-ops system files with diff preview + compat check
```
Or just paste a job URL or description directly -- career-ops auto-detects it and runs the full pipeline.
In Codex, slash commands are not guaranteed. Use the same mode names in a prompt instead, or call them from `codex exec`.
## How It Works
```
You paste a job URL or description
│
▼
┌──────────────────┐
│ Archetype │ Classifies: LLMOps / Agentic / PM / SA / FDE / Transformation
│ Detection │
└────────┬─────────┘
│
┌────────▼─────────┐
│ A-H Evaluation │ Match, gaps, comp research, STAR stories, legitimacy
│ (reads cv.md) │
└────────┬─────────┘
│
┌────┼────┐
▼ ▼ ▼
Report PDF Tracker
.md .pdf entry
```
## Antigravity CLI Integration
career-ops supports Antigravity CLI natively, the same way it supports Claude Code and OpenCode. All slash commands are available through the shared skill entrypoint, using the same `modes/*.md` evaluation logic.
Google has transitioned consumer Gemini CLI access to Antigravity CLI. `GEMINI.md` is now a no-op compatibility guard so Antigravity does not duplicate the full project instructions when it reads both `AGENTS.md` and `GEMINI.md`.
### Native Antigravity CLI
```bash
# 1. Run in the career-ops directory
cd career-ops
agy
# 2. Use the unified /career-ops command with subcommands:
/career-ops "Senior AI Engineer at Anthropic..."
/career-ops pipeline
/career-ops scan
/career-ops pdf
/career-ops tracker
```
The skill is defined using the open standard in `.agents/skills/career-ops/SKILL.md` and symlinked/referenced for each supported CLI (e.g. `.claude/`, `.qwen/`, `.antigravitycli/`, `.grok/`). Cursor automatically discovers the shared skill in `.agents/skills/`.
## Codex Integration
career-ops supports Codex through the same shared router, but the invocation model is different from CLIs that auto-register slash commands. For the full guide, see [docs/CODEX.md](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/CODEX.md).
### Interactive Codex
```bash
cd career-ops
codex
```
Slash commands are not guaranteed in Codex. If `/career-ops` is unavailable, ask Codex to run the mode directly in plain language:
```text
Evaluate this JD with career-ops auto-pipeline: https://company.com/jobs/123
Run the career-ops scan mode and summarize new matches.
Run the career-ops pipeline mode for data/pipeline.md.
Run the career-ops pdf mode for the latest evaluated role.
Run the career-ops tracker mode and summarize the current statuses.
```
### One-shot Codex (`codex exec`)
```bash
codex exec "Evaluate this JD with career-ops auto-pipeline: https://company.com/jobs/123"
codex exec "Run career-ops scan mode in this repo and summarize new matches."
codex exec "Run career-ops pipeline mode for data/pipeline.md."
codex exec "Run career-ops pdf mode for the latest evaluated role."
codex exec "Run career-ops tracker mode and summarize the current statuses."
```
## Grok Build CLI Integration
career-ops supports Grok Build CLI natively, the same way it supports Claude Code and OpenCode. `AGENTS.md` is auto-loaded as project rules, and all slash commands are available through the shared skill entrypoint.
### Native Grok Build CLI
```bash
# 1. Run in the career-ops directory
cd career-ops
grok
# 2. Use the unified /career-ops command with subcommands:
/career-ops "Senior AI Engineer at Anthropic..."
/career-ops pipeline
/career-ops scan
/career-ops pdf
/career-ops tracker
```
For headless batch workers, use `grok -p "prompt"` (add `--yolo` to auto-approve tool executions).
## Pi Integration
career-ops supports [Pi](https://github.com/earendil-works/pi) natively, with no wrapper file to maintain: Pi reads `AGENTS.md` from the repo root as project context and discovers the shared skill at `.agents/skills/career-ops/SKILL.md` on its own. The router is then available as `/skill:career-ops`.
### Native Pi
```bash
# 1. Run in the career-ops directory
cd career-ops
pi
# 2. Use the shared skill with subcommands:
/skill:career-ops "Senior AI Engineer at Anthropic..."
/skill:career-ops pipeline
/skill:career-ops scan
/skill:career-ops pdf
/skill:career-ops tracker
```
### One-shot Pi (`pi -p`)
```bash
pi -p "Evaluate this JD with career-ops auto-pipeline: https://company.com/jobs/123"
pi -p "Run career-ops scan mode and summarize new matches."
pi -p "Run career-ops tracker mode and summarize the current statuses."
```
If a Pi build gates project resources behind a trust decision, run `/trust` once inside the repo and restart `pi` so the project skill loads (`/trust` applies to future Pi processes), or start with `-a`, which trusts a single run and needs no restart.
### Standalone Gemini API Script (No CLI install needed)
```bash
# 1. Get a free API key at https://aistudio.google.com/apikey
cp .env.example .env
# Edit .env, set GEMINI_API_KEY=your_key_here
# 2. Install dependencies
npm install
# 3. Evaluate a job description
node gemini-eval.mjs "We are looking for a Senior AI Engineer..."
node gemini-eval.mjs --file ./jds/my-job.txt
node agent-inbox.mjs add "..." # queue a request for the next session
npm run gemini:eval -- "JD text here"
```
> **Free tier:** Both options work without billing. Native CLI uses Google OAuth; the API script uses `gemini-3.6-flash` (rate limits are model- and tier-dependent; see Google AI docs for current quotas).
## Pre-configured Portals
The scanner comes with **100+ companies** ready to scan and **35+ search queries** across major job boards. Copy `templates/portals.example.yml` to `portals.yml` and add your own:
**AI Labs:** Anthropic, OpenAI, Mistral, Cohere, LangChain, Pinecone
**Voice AI:** ElevenLabs, PolyAI, Parloa, Hume AI, Deepgram, Vapi, Bland AI
**AI Platforms:** Retool, Airtable, Vercel, Temporal, Glean, Arize AI
**Contact Center:** Ada, LivePerson, Sierra, Decagon, Talkdesk, Genesys
**Enterprise:** Salesforce, Twilio, Gong, Dialpad
**LLMOps:** Langfuse, Weights & Biases, Lindy, Cognigy, Speechmatics
**Automation:** n8n, Zapier, Make.com
**European:** Factorial, Attio, Tinybird, Clarity AI, Travelperk
**Job boards searched:** 55+ provider modules cover ATS APIs, board-wide feeds, XML/RSS feeds, markdown feeds, and local parsers. See [Supported job boards](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/SUPPORTED_JOB_BOARDS.md) for the full table.
Keep the list current: `portals.yml` is designed to stay live, not be a one-time setup file. See [Keeping portals.yml live](https://github.com/career-ops-hq/career-ops/blob/HEAD/docs/KEEPING_PORTALS_LIVE.md) for the house rule that adds new companies automatically and the commands to validate the file after every change.
By default `node scan.mjs` (a.k.a. `npm run scan`) trusts what each ATS feed returns. Some companies leave stale postings in their public API even after the role is closed, so those expired entries can leak into `pipeline.md`. Pass `--verify` to launch Playwright after the API pass and drop expired postings before they hit the pipeline:
```bash
node scan.mjs --verify # zero-token discovery + Playwright liveness check
```
The verification is sequential and only runs against new offers (after dedup), so the cost stays bounded.
## Dashboard TUI
The built-in terminal dashboard lets you browse your pipeline visually:
```bash
npm run serve:dashboard # launch the TUI
npm run build:dashboard # optional: build the standalone binary
```
Features: 6 filter tabs, 4 sort modes, grouped/flat view, lazy-loaded previews, inline status changes.
There is also an **experimental web UI** (alpha and opt-in: nothing runs unless you start it): see [`web/README.md`](web/README.md).
## Project Structure
```
career-ops/
├── AGENTS.md # Canonical agent instructions (all CLIs)
├── CLAUDE.md # Claude Code wrapper (imports AGENTS.md)
├── CODEX.md # Codex wrapper (imports AGENTS.md)
├── OPENCODE.md # OpenCode wrapper (imports AGENTS.md)
├── GEMINI.md # Legacy no-op guard to avoid Antigravity duplicate context
├── cv.md # Your CV (create this)
├── article-digest.md # Your proof points (optional)
├── config/
│ └── profile.example.yml # Template for your profile
├── modes/ # Skill modes
│ ├── _shared.md # Shared context (customize this)
│ ├── oferta.md # Single evaluation
│ ├── pdf.md # PDF generation
│ ├── cover.md # Cover letter generation
│ ├── email.md # Formal application email drafts
│ ├── scan.md # Portal scanner
│ ├── batch.md # Batch processing
│ └── ...
├── templates/
│ ├── cv-template.html # ATS-optimized CV template
│ ├── portals.example.yml # Scanner config template
│ └── states.yml # Canonical statuses
├── batch/
│ ├── batch-prompt.md # Self-contained worker prompt
│ └── batch-runner.sh # Orchestrator script
├── dashboard/ # Go TUI pipeline viewer
├── data/ # Your tracking data (gitignored)
├── reports/ # Evaluation reports (gitignored)
├── output/ # Generated PDFs (gitignored)
├── fonts/ # Space Grotesk + DM Sans
├── docs/ # Setup, customization, budget guide, architecture
└── examples/ # Sample CV, report, proof points
```
## External Data Directory (Optional)
By default, user-layer data (such as `cv.md`, `portals.yml`, and `data/` / `reports/` / `output/` folders) lives inside the project root folder.
To separate your personal data from the code (making it easier to switch branches, pull updates, or test multiple profiles), you can configure an external data directory using the following precedence:
1. **Environment Variables:** Set the `CAREER_OPS_ROOT` or `CAREER_OPS_DATA_DIR` environment variable:
```bash
export CAREER_OPS_ROOT=~/my-career-data
```
2. **Marker File:** Create a `.career-ops-data` file in the repository root containing the path to your data directory.
3. **Default:** Defaults to the repository root.
Once resolved, all user files are resolved and written relative to that folder, while prompt files and scripts continue to resolve relative to the repository.
- **Tracker Override:** You can also set `CAREER_OPS_TRACKER` to override the applications tracker file path directly.
- **Writes:** All write operations (such as merges) canonically target `{DATA_ROOT}/data/applications.md`.
- **Scanner config:** `portals.yml` is read and validated at `{DATA_ROOT}/portals.yml`, so `node validate-portals.mjs` checks the same file `scan.mjs` reads.
- **Generated documents:** tailored CVs and cover letters are written under `{DATA_ROOT}/output/`, and the PDF manifest that links them to a report lives at `{DATA_ROOT}/data/pdf-index.tsv`. While `CAREER_OPS_TRACKER` is unset, the tracker workspace that bounds those writes is the data root, not the checkout.
- **PDFs under a tracker override:** `generate-pdf.mjs` resolves `CAREER_OPS_TRACKER` before it derives the workspace, so with the override set the workspace is the folder that holds that tracker (or the folder above it, when the tracker sits in a `data/` folder). The CV's HTML and every PDF must then sit inside that workspace, and the manifest moves to its `data/pdf-index.tsv`. Cover letters still target `{DATA_ROOT}/output/`, so they are refused when that folder falls outside the tracker's workspace.
- **Code layer stays put:** `node_modules/`, `providers/`, `modes/` and the scripts themselves always resolve against the repository, never the data root.
The Go dashboard TUI, Node.js scripts, and AI agent modes all automatically respect this resolution hierarchy.
## Tech Stack
- **Agent**: AI coding CLI with shared skills and modes (`AGENTS.md` + CLI wrapper)
- **PDF**: Playwright + HTML template
- **Cover letters**: HTML template + Playwright (A4 PDF, same pipeline as CVs)
- **Scanner**: Playwright + Greenhouse API + WebSearch
- **Dashboard**: Go + Bubble Tea + Lipgloss (Catppuccin Mocha theme)
- **Data**: Markdown tables + YAML config + TSV batch files
Also runs on any agent-skill-standard CLI. See Supported CLIs.
> README 较长，以上为前 40000 个字符。完整内容：https://github.com/career-ops-hq/career-ops
Created by @santifer
%5Cs*%24&replace=%241%20signatories&label=THE%20CAREEROPS%20MANIFESTO&color=DD7627&style=for-the-badge&labelColor=2b3137){kind=icon}
