# What Programming Languages Does Career-Ops Support and How to Switch Between Modes

> Learn which programming languages Career-Ops supports and how to easily switch between German, French, Japanese, Arabic, and Chinese language modes by updating a configuration file.

- Repository: [Santiago Fernández de Valderrama/career-ops](https://github.com/santifer/career-ops)
- Tags: how-to-guide
- Published: 2026-07-03

---

**TLDR:** Career-Ops is built entirely in JavaScript/Node.js and supports multiple natural-language output modes—including German, French, Japanese, Arabic, and Chinese—by switching the `language.modes_dir` value in [`config/profile.yml`](https://github.com/santifer/career-ops/blob/main/config/profile.yml).

Career-Ops is a Node.js automation pipeline designed for job search optimization. While the tool itself is written exclusively in **JavaScript** using ECMAScript modules (`*.mjs`), it offers extensive **multi-language support** for generating localized cover letters, CVs, and interview preparation materials. Understanding what programming languages Career-Ops supports versus how it handles natural language output is key to configuring your workflow.

## Implementation Language: JavaScript and Node.js

According to the santifer/career-ops source code, the entire system is powered by **JavaScript/Node.js** and contains no compiled language runtimes. The core automation scripts—including `scan.mjs` for portal scanning and `generate-pdf.mjs` for PDF generation—are written as ECMAScript modules that execute on a modern V8 runtime. This architecture ensures cross-platform compatibility without requiring Go, Rust, or Python interpreters.

Key entry points in the repository include:

- `scan.mjs` – Entry point for portal scanning logic
- `generate-pdf.mjs` – PDF generation using Node.js and Playwright
- `run.mjs` – Executes specific evaluation modes
- `auto-pipeline.mjs` – Orchestrates the full automation workflow

Because the entire stack is JavaScript-based, you can inspect or modify any logic using standard Node.js debugging tools.

## Supported Language Modes for Output Localization

Beyond its implementation language, Career-Ops provides **language-specific modes** that localize output for job searches in different natural languages. These modes are not separate programming languages but rather collections of localized markdown prompt files stored in `modes/<lang>/` directories.

Supported language codes include:

- `de` – German
- `fr` – French
- `ja` – Japanese
- `ar` – Arabic
- `zh` – Chinese
- `pt` – Portuguese
- `es` – Spanish
- `pl` – Polish

Each mode directory contains a [`_shared.md`](https://github.com/santifer/career-ops/blob/main/_shared.md) file that overrides or extends the base English prompts with locale-specific phrasing, date formats, and BCP-47 language codes used by PDF and HTML templates.

## How Language Modes Work Under the Hood

The Career-Ops engine uses a hierarchical prompt system to render localized content. As documented in [`AGENTS.md`](https://github.com/santifer/career-ops/blob/main/AGENTS.md), the high-level language-mode selection logic relies on the `language.modes_dir` field in your configuration.

When processing a request, the core engine follows this flow:

1. The **core JavaScript engine** reads the `language.modes_dir` value from [`config/profile.yml`](https://github.com/santifer/career-ops/blob/main/config/profile.yml)
2. **[`_shared.md`](https://github.com/santifer/career-ops/blob/main/_shared.md)** in the target directory contains generic writing rules and language-agnostic placeholders
3. **Language-specific sub-directories** provide overrides for local conventions and formatting
4. The **CLI** or agent (such as Claude/Opencode) loads these prompts at runtime to generate localized output

This design means that switching from English to German does not require changing the underlying JavaScript code; only the prompt source directory changes.

## How to Switch Between Language Modes

Switching the output language requires updating a single field in your user profile and notifying the agent. The recommended approach uses version-controlled configuration rather than runtime flags.

### Step 1: Update the Profile Configuration

Edit [`config/profile.yml`](https://github.com/santifer/career-ops/blob/main/config/profile.yml) to point to your desired language directory:

```yaml

# config/profile.yml

language:
  modes_dir: modes/de

```

Replace `de` with any supported two-letter code (`fr`, `ja`, `ar`, `zh`, etc.).

### Step 2: Notify the Agent

When starting a new session, explicitly remind the agent to respect the configuration field:

```text
Claude, please check `profile.yml` – I have set `language.modes_dir` to `modes/de`.

```

This step is necessary because the documentation treats this as a convention rather than an automatic schema enforcement.

### Step 3: Execute the Mode

Run any standard command to generate localized output:

```bash
node run.mjs evaluate https://example.com/job

```

Or use the full pipeline:

```bash
node auto-pipeline.mjs https://jobs.example.com/role123

```

The engine will automatically load prompts from `modes/de/` instead of the default English `modes/` folder, affecting all downstream modes including `pipeline`, `oferta`, `apply`, and `interview`.

## Programmatic Language Detection

If you are extending Career-Ops or building custom integrations, you can access the language mode programmatically by reading the profile configuration:

```javascript
import { readFileSync } from 'fs';
import YAML from 'yaml';

const profile = YAML.parse(readFileSync('config/profile.yml', 'utf8'));
const modeDir = profile.language?.modes_dir ?? 'modes';
const shared = await import(`${modeDir}/_shared.md`);
// Use `shared` to build localized prompts

```

This pattern ensures your extensions respect the user's selected language mode without hardcoding paths.

## Summary

- Career-Ops is implemented entirely in **JavaScript/Node.js** using ECMAScript modules (`*.mjs`), with no dependencies on compiled languages.
- The repository supports **natural-language output modes** for German, French, Japanese, Arabic, Chinese, Portuguese, Spanish, Polish, and others via the `modes/<lang>/` directory structure.
- Switching languages requires setting `language.modes_dir` in [`config/profile.yml`](https://github.com/santifer/career-ops/blob/main/config/profile.yml) and reminding the agent to check this field at the start of each session.
- All modes rely on a hierarchical prompt system using [`_shared.md`](https://github.com/santifer/career-ops/blob/main/_shared.md) files to maintain consistent formatting while allowing locale-specific customization.

## Frequently Asked Questions

### Is Career-Ops written in Python or JavaScript?

Career-Ops is written entirely in **JavaScript** and runs on Node.js. The repository contains no Python, Go, or Rust code; all core functionality—including the scanner, evaluator, and PDF generator—resides in `.mjs` files like `scan.mjs` and `generate-pdf.mjs`.

### Can I add a custom language mode to Career-Ops?

Yes. Create a new directory under `modes/` using a standard two-letter language code (e.g., `modes/it/` for Italian), add a [`_shared.md`](https://github.com/santifer/career-ops/blob/main/_shared.md) file with your localized prompts, and set `language.modes_dir: modes/it` in [`config/profile.yml`](https://github.com/santifer/career-ops/blob/main/config/profile.yml). The engine will automatically load your custom mode as long as the directory structure matches existing modes.

### Do I need to restart the agent after changing the language mode?

You do not need to restart the agent, but you must **remind it once per session** to check [`config/profile.yml`](https://github.com/santifer/career-ops/blob/main/config/profile.yml) for the `language.modes_dir` setting. The system relies on this convention rather than automatic schema validation, so explicitly stating "check my profile, I set language.modes_dir to modes/fr" ensures the agent loads the correct prompts.

### What is the difference between the implementation language and language modes in Career-Ops?

The **implementation language** is JavaScript, which powers the automation engine and CLI. **Language modes** refer to the natural-language localization of output content (cover letters, CVs) stored in `modes/<lang>/` directories. You can run the JavaScript engine in English while generating job application materials in Japanese, German, or Arabic by switching the mode configuration.