Career Mode

Your sessions already contain your best career stories. Career Mode extracts them before you forget.

You just spent four hours debugging a race condition, or designed a provider abstraction that handles five LLM backends, or ripped out legacy auth middleware because legal flagged a compliance gap. In a week you'll remember "fixed some bug." In six months, nothing. Interviews and resumes are reconstructed from faded memory, months after the specifics vanished.

Career Mode captures session context at peak richness — right now, while the conversation is still open — and translates it into artifacts you can actually use: STAR-format interview answers, XYZ resume bullets, and technical narratives ready for a portfolio or blog post.

"Couldn't you just write a skill for this?"

Yes — and that's exactly what Career Mode is not.

Useful shortcut:: Career Mode is a different category of thing:

The slash command (/career-mode) is the lowest-friction entry point. It is not the whole product.

How it works

A single pipeline — ingestor → translators → output — exposed four ways:

| Surface | When you'd use it | Context source | |---|---|---| | /career-mode slash command | End of a Claude Code session | Full conversation transcript — richest signal | | MCP server (career-mode-mcp) | Any MCP-capable host: Claude Desktop, custom tooling | Tool call args (session_summary), or git fallback | | CLI (career-mode generate) | Scripts, CI, or piping a git diff | --json file, or local git log/diff | | git commit hook | Every commit, zero extra steps | git log + diff — no session required |

All four surfaces feed the same pipeline. The /career-mode slash command produces the richest output because it has the full conversation; the git hook produces the leanest because it works purely from diff context. Same typed contract at the output end either way.

The pipeline

session context  →  ingestor  →  SessionSummary  →  translators  →  connector  →  artifact

Ingestor normalizes raw context — a conversation transcript, a git diff, or a JSON blob — into a validated SessionSummary schema:

{
  one_liner, problem_statement, approach,
  tradeoffs: [{ decision, reasoning, alternative_considered }],
  dead_ends: string[],
  technologies: string[],
  patterns_used: string[],
  complexity_signals: { files_touched, lines_changed, test_coverage, debugging_involved }
}

This typed contract is what makes translators swappable. Adding a new output mode means writing a new translator against the schema — not re-engineering context extraction.

Translators are per-mode LLM calls against versioned prompt templates. Prompt quality is iterable independently of code — pin a version, A/B test, roll back. A skill's prompt is frozen in the .md file.

Connectors are swappable output destinations. local writes .md files and maintains index.yml. gist pushes each artifact to a GitHub Gist and returns a shareable URL.

Quickstart

1. Install

npm install -g @abhinavravich1999/skill-forge

Or run without installing:

npx @abhinavravich1999/skill-forge generate --help

2. Configure your LLM provider

Career Mode has its own LLM client, independent of whatever powers your Claude Code session. The recommended path is openai-compatible — it works with DeepSeek, Groq, Together, Fireworks, xAI, LM Studio, vLLM, Ollama, and OpenAI itself.

cp career-mode.config.yaml ~/.career-mode/config.yaml
cp .env.example .env

Edit ~/.career-mode/config.yaml. DeepSeek is fast and cheap — a good default:

provider: openai-compatible
model: deepseek-chat
base_url: https://api.deepseek.com/v1
api_key: ${DEEPSEEK_API_KEY}       # resolved from .env — secrets stay out of yaml

Add the key to .env:

DEEPSEEK_API_KEY=sk-...

.env is loaded from project root first, then ~/.career-mode/.env. Shell env always wins.

Skip the config file entirely and the provider auto-detects from env:

| Env var set | Provider used | |---|---| | ANTHROPIC_API_KEY | Anthropic (Claude, native SDK) | | OPENAI_API_KEY | OpenAI (api.openai.com) | | Neither | Ollama at localhost:11434 |

3. Install the slash command

# macOS / Linux
cp claude-code-integration/commands/career-mode.md ~/.claude/commands/career-mode.md

# Windows (PowerShell)
Copy-Item claude-code-integration\commands\career-mode.md "$env:USERPROFILE\.claude\commands\career-mode.md"

Restart Claude Code. /career-mode is now available in any session.

4. (Optional) Register the MCP server

Register Career Mode as an MCP server so any MCP-capable client can call it as a tool — including Claude Code, Claude Desktop, or your own tooling:

claude mcp add skill-forge -- npx --package=@abhinavravich1999/skill-forge skill-forge-mcp

Or add it to .mcp.json directly — see claude-code-integration/mcp/.mcp.json. Full tool schemas and the reasoning for running both the slash command and MCP server: docs/mcp-server.md.

5. (Optional) Install the git commit hook

Fire Career Mode on every commit — no session required, no extra steps:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "pattern": "git commit",
        "command": "npx @abhinavravich1999/skill-forge generate --mode portfolio-bullet"
      }
    ]
  }
}

Add this to ~/.claude/settings.json under hooks.

Using the slash command

At the end of a Claude Code session:

/career-mode

Claude synthesizes the session into a structured summary, runs it through the pipeline, and writes an artifact to ~/.career-mode/artifacts/. The output path is printed in the terminal.

Specify the mode:

/career-mode --mode interview-qa
/career-mode --mode portfolio-bullet
/career-mode --mode technical-deep-dive
/career-mode --mode all

Default is interview-qa. See docs/slash-command.md for a full walkthrough.

Output modes

interview-qa

2–4 STAR-format interview questions with full answers (Situation, Task, Action, Result), follow-up questions an interviewer would actually ask, and a calibration note on how to pitch the answer for your experience level.

portfolio-bullet

3–5 resume bullets in XYZ format ("Accomplished X by doing Y, resulting in Z"). Calibrated to experience_level and target_role in config.

technical-deep-dive

A technical narrative for a blog post, design doc, or engineering portfolio — problem, approach, tradeoffs, and lessons learned, structured for an engineering audience.

all

All three modes, separate files.

Configuration

~/.career-mode/config.yaml (global) or <project-root>/career-mode.config.yaml (project override — takes precedence):

experience_level: senior       # junior | mid | senior | staff
tone: balanced                 # technical | business | balanced
output_dir: ~/.career-mode/artifacts

# Provider — auto-detected from env if omitted
# provider: anthropic
# model: claude-sonnet-4-6

# provider: openai
# model: gpt-4o-mini

# provider: ollama
# model: llama3.2
# base_url: http://localhost:11434/v1

# provider: openai-compatible   # Groq, Together AI, LM Studio, DeepSeek, etc.
# model: mixtral-8x7b-32768
# base_url: https://api.groq.com/openai/v1
# api_key: gsk_...

# Optional calibration
# target_role: Staff Engineer
# company_size: startup         # startup | mid | enterprise
# default_mode: portfolio-bullet

# Output connector
# connector: gist               # also pushes each artifact to a GitHub Gist
# gist_token: ghp_...           # or set GITHUB_TOKEN (needs `gist` scope)
# gist_public: false            # default: secret gist

CLI reference

# Generate from a session JSON (slash command path)
npx tsx src/index.ts generate --mode interview-qa --json ~/.career-mode-session.json

# Generate from git context (hook path — no --json)
npx tsx src/index.ts generate --mode portfolio-bullet

# List all generated artifacts
npx tsx src/index.ts list

# Push the most recent artifact to a GitHub Gist
GITHUB_TOKEN=ghp_... npx tsx src/index.ts share

# Override output directory
npx tsx src/index.ts generate --mode all --output-dir ./my-artifacts

Project structure

src/
  types/          # Zod schemas — SessionSummary, TranslatorOutput, CalibrationConfig
  claude/         # LLM client — provider factory + Anthropic / OpenAI-compatible providers
  config/         # Config loader (project-root → home fallback chain)
  adapters/       # Input adapters — git context (hook path), stdin/file (slash command path)
  ingestor/       # Normalizes all input paths into a typed SessionSummary
  prompts/        # Versioned prompt templates (.txt) per mode
  translators/    # One translator per mode — LLM call, validation, markdown render
  output/         # Renderer (frontmatter + header + content) + connector interface
    connectors/   # LocalFileConnector (disk + index.yml), GistConnector
  mcp/            # server.ts — MCP server exposing the pipeline as three tools
  index.ts        # CLI entry point — `generate`, `list`, `share` commands

claude-code-integration/
  commands/       # career-mode.md — install as a Claude Code slash command
  hooks/          # post-session.json — reference hook config
  mcp/            # .mcp.json — reference MCP server registration

tests/
  fixtures/       # sample-session.json — realistic test fixture
scripts/
  test-local.ts   # Smoke test: full pipeline against the fixture

Status

v0.1 — working, weekend-built. Tested on:

• Anthropic API (Claude Sonnet), Ollama (local, no key), DeepSeek via openai-compatible
• /career-mode slash command path end-to-end
• CLI (generate, list, share) against the sample fixture
• MCP server two ways: scripts/mcp-smoke-test.ts drives initialize → tools/list → list_career_artifacts → generate_career_artifact over the MCP client SDK; separately, claude mcp add + claude mcp get confirms Claude Code's own MCP client connects (✔ Connected)
• .env loading with ${VAR} config indirection, verified by scripts/deepseek-smoke-test.ts
• Gist connector — offline (mocked fetch) and live via the MCP share_last_artifact tool

Not yet tested end-to-end:

• OpenAI direct provider (provider: openai — the openai-compatible path with base_url: https://api.openai.com/v1 is equivalent and works)
• git commit hook path
• npm link / npx career-mode-mcp as installed global binaries

Contributions and issues welcome.