# accounts

Adopt this skill: https://proskills.md/skills/other/qbeka-jev-job-search-claude-skills-accounts

Page: https://proskills.md/skills/other/qbeka-jev-job-search-claude-skills-accounts
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: .claude/skills/accounts/SKILL.md
size: 6188
sha: 782812db40cf6589f0e98cffbcb8f628fd492d87
upstream: https://github.com/qbeka/jev-job-search/blob/main/.claude/skills/accounts/SKILL.md

```text
---
name: accounts
description: Let the tool apply on job boards that want an account (Workday today). Use when the user says /accounts or /account, with or without a subcommand (signin, password, add, setup, clear, off, on, forget, gmail), "Workday", "sign in for me", "why are Workday jobs skipped", or asks about verification emails.
argument-hint: "[signin <employer> | password <employer> | add workday | setup <employer> | clear | off | on | forget <employer or all> | gmail]"
model: claude-sonnet-5-5
effort: medium
---

# /accounts

The user types a short command; you run the tool for them. They should
never have to type `npx` or edit a file. `docs/ACCOUNTS.md` is the
reference. Everything here is off until the user turns it on.

There are three ways to use it. **Lead with the first.** Offer the second
when a session has ended, and the third only when they ask for less work
per employer, and say that it is experimental.

1. They sign in once at an employer, themselves; the tool keeps the session.
2. They store that employer's password; the tool signs in when the session ends.
3. Experimental: the tool makes accounts where they have none.

## `/accounts` with nothing after it

Run `npx jev accounts`. If nothing is set up, this is the guided setup:

1. Say in two sentences what this is: Workday employers each want an
   account, and the simplest way is to sign in once yourself.
2. Run `npx jev status` and name the two or three Workday employers with
   the best jobs they are missing (`npx jev queue` lists skipped jobs with
   `workday` as the reason; use the companies, not ids).
3. Ask which one to start with, then do `/accounts signin <employer>`.
4. After it works, run `npx jev discover` and say how many jobs at that
   employer are now in the queue. Offer `/apply`.

If something is set up, say what, what waits for them, and the next step.

## What the user can type

| They type | You do |
|---|---|
| `/accounts signin <employer>` | Show `npx jev accounts signin <employer>` in a `bash` block. It opens the employer's page in the tool's Chrome window; they sign in there themselves. Tell them to click Run and then look at that window. |
| `/accounts password <employer>` | Run `npx jev accounts password <employer>`. A window opens on their Mac; they type that employer's password there, twice. You never see it. With no employer it stores the one password they use on accounts they already had. |
| `/accounts browser <employer>` | Only when they say they saved that employer's password in the tool's Chrome and want the tool to use it. Run `npx jev accounts browser <employer>`. The tool then presses Sign In once that browser has filled the page in; it types nothing and never reads the password. `--off` takes it back. |
| `/accounts add workday` | The questions below. Run it with `--preview` first and read what it allows back to them. Save only after a yes, with exactly the flags they agreed to. |
| `/accounts setup <employer>` | Show `npx jev accounts setup <employer>` in a `bash` block. It signs in, or makes the account. They click Run. |
| `/accounts clear` | `npx jev accounts clear`, after they fixed what paused an account. |
| `/accounts off` / `/accounts on` | `npx jev accounts off` / `on`. Say that everything set up is kept. |
| `/accounts forget <employer or all>` | Run it without `--yes` first and read back what it removes. After a yes, run it with `--yes`. Say that the account at the employer still exists. |
| `/accounts gmail` | Only if they want verification emails read for them. Say first that the default needs no setup: they click the link and type `/resume`. If they still want it, walk through "Verification emails" in `docs/ACCOUNTS.md` one step at a time. Do not promise how long it takes. Then `/accounts gmail <file>` runs `npx jev gmail connect --client <file>`. |

After any of these, run `npx jev accounts` and read the result back.

## The questions for `add workday`

Say that this is experimental before asking. Each is a separate yes:

1. May the tool **make** an account where an employer has none for you?
   Each is a real account at that employer, in your name. (`--create`)
2. May it tick the box that accepts each employer's **candidate-account
   terms** for you, without your reading them one by one? A marketing box
   is never ticked. (`--terms`)
3. May it read the **verification email** an employer sends? That needs
   Gmail connected. Without it you click each link. (`--verify-email`)

They choose no password: each new account gets its own random one, kept in
their Keychain. `--max-new 3` is the default.

## What you never do

- **Never ask for, read, type or repeat a password, a code or a token**,
  in chat, in a file or in a command. Never read the Keychain, `.env` or
  the tool's Chrome profile.
- **Never start anything that signs in or signs up at an employer.** That
  is `accounts signin`, `accounts setup`, `apply` on a Workday job in a
  real run, `daily` and `resume --submit` when Workday is set up. Show the
  command in a `bash` block; the app puts a Run button on it. A rehearsal
  (`--dry`) of a Workday job signs in to an account they have and makes
  nothing; treat it the same way.
- **Never pass a human check**: a CAPTCHA, a phone code, a passkey, or the
  code a board emails because it suspects a robot.
- **Never allow more than they said.** No flag they did not agree to, and
  no edit to `data/accounts.json` by hand.
- If the permission system declines a command, do not try another way.
  Show the command in a `bash` block for them to run with one click.

## When a sign-in stops

The reason is on the job's row (`/status`). In their words:

- **The employer refused the password.** Either they sign in themselves in
  the tool's Chrome window, or they type `/accounts password <employer>`
  with the right one. Then `/resume`.
- **A robot check, a phone code, a passkey, single sign-on.** They do it
  in the tool's window. Then `/resume`.
- **A verification email.** They click its link in their own mail. Then
  `/resume`.
- **No account there, in a rehearsal.** `/accounts setup <employer>`, or
  `/accounts signin <employer>` to make it themselves.
```

## File: README.md
upstream: https://github.com/qbeka/jev-job-search/blob/main/README.md

````text
<div align="center">

<img src="docs/assets/mascot.svg" width="168" alt="Jev the beaver, holding a filled-in application form with a green check mark">

# jev-job-search

**The job search that fills the forms for you.**

Finds the roles, fills each application in a Chrome window you can watch,<br>
reads every answer back from the page, and sends only what you approve.

[![ci](https://github.com/qbeka/jev-job-search/actions/workflows/ci.yml/badge.svg)](https://github.com/qbeka/jev-job-search/actions/workflows/ci.yml)
[![release](https://img.shields.io/github/v/release/qbeka/jev-job-search?label=release)](https://github.com/qbeka/jev-job-search/releases)
[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
![runs on macOS, Linux and Windows](https://img.shields.io/badge/runs%20on-macOS%20%7C%20Linux%20%7C%20Windows-8a5a3b)
![node 22 or newer](https://img.shields.io/badge/node-22%2B-3c873a)

[Quick start](#quick-start) · [How it works](#how-it-works) · [Commands](#commands) · [What it will not do](#what-it-will-not-do) · [Cost](#what-it-costs) · [Docs](#docs)

</div>

<p align="center">
  <img src="docs/assets/demo.svg" width="820" alt="A run applying to three jobs: one is sent after every value is read back, one waits for a code only you can type, one is left for you because it asks for a signature">
</p>
<p align="center"><sub>An illustration of what a run prints. The companies are made up; the person is the one in <code>data/profile.example.json</code>.</sub></p>

## What this is

An open-source job application tool for students and new graduates applying to software roles in Canada, the United States or remotely. You talk to it through a coding agent ([Claude Code](https://claude.com/claude-code) by default, Codex if you prefer), and it does the paperwork:

- **`/discover`** reads public job lists and company boards and ranks what fits you.
- **`/apply`** fills each form in its own Chrome window, checks every answer on the page, and sends the ones you approve.
- **`/report`** opens a dashboard on your own machine with everything that was sent and everything that needs you.

Two models share the thinking. [JEV](https://openrouter.ai/typesafe/jev-1.13) makes every decision that has a fixed set of answers (which of your details goes in this box, which option, how good a fit this job is) for a fraction of a cent. A writer, Claude on your own subscription unless you pick another, writes the sentences. The code does the rest.

> This is an independent open-source project. It is not affiliated with, endorsed by or maintained by Anthropic, OpenAI, TypeSafe, OpenRouter, or any job board. There is no token, coin or paid tier; the only ways to support it are using it and contributing on GitHub.

## Does it actually work?

It is how I run my own search. I sent 100 applications in less than 10 minutes across Ashby, Lever, Workable, Rippling, BambooHR, Jobvite and JazzHR forms, for about a dollar in JEV, while fixing what it got wrong on each new kind of form. Every answer on every one of those forms was read back from the page before it was sent, and every form it could not finish truthfully is in `applications/manual.csv` with the reason. The numbers it reports about itself are in [How well it works](docs/USAGE.md#how-well-it-works). I will add what came of the applications once I know.

It is a beta. Forms on boards it has not met will hold, and it says so.

## Why it is different

- **Nothing is trusted until it is read back.** Every value is read from the page after it is written. A wrong dropdown pick, a date a masked box mangled, or a value a site quietly dropped is caught before Submit, not after.
- **What goes on a form comes from your profile.** Your right to work is worked out in code, per country. Dates and education are copied. A written answer that names a number, a tool or a company your profile does not is refused.
- **Decisions and sentences are split.** JEV returns probabilities, not text, in about half a second. The writer only writes. A form with no open question never calls the writer at all.
- **What it cannot finish truthfully, it sets aside.** A signature, an NDA, a robot check and an emailed code are yours. The form is left open or listed for you with the reason, and the run moves on.
- **It never sends twice, and never unless you asked.** Sending needs your yes. A click with no confirmation is settled before that job is touched again.
- **It learns per site.** How each board's controls take values is noted after every form, read before the next, and shared through the repo.
- **Your data stays yours.** Everything about you lives in git-ignored files on your machine. Passwords live in your system's own secret store and are never shown to a model.

## Quick start

You need [Node.js](https://nodejs.org) 22 or newer, Google Chrome, a coding agent, and a JEV key with a few dollars of credit, from [TypeSafe](https://console.typesafe.ai/keys) or [OpenRouter](https://openrouter.ai/keys) (same model, same price).

```bash
git clone https://github.com/qbeka/jev-job-search
cd jev-job-search
npm install
```

Then open your agent in the folder and ask for the setup:

```bash
claude      # then type: /setup
```

`/setup` checks what is installed, reads your resume PDF and anything else you drop into `documents/`, asks only what those do not say, opens `.env` for you to paste your JEV key (TypeSafe or OpenRouter), builds your profile, finds jobs, rehearses three forms without sending so you can correct what it got wrong, and ends with one real application filled and waiting for your yes. About 20 minutes, most of it your answers.

After that, the whole workflow is three commands:

```
/discover                                        find and rank jobs
/apply                                           fill, check and send the best ones
/apply https://jobs.ashbyhq.com/company/job-id   one posting you found yourself
```

> [!IMPORTANT]
> Everything about you stays in git-ignored files (`data/`, `documents/`, `applications/`, `.env`), so your own clone can be pushed anywhere without leaking anything. Fork only to contribute.

<details>
<summary><b>Using Codex or another agent instead of Claude Code</b></summary>

<br>

`AGENTS.md` gives Codex, Cursor, Gemini CLI and other agents the same rules and the same skills. In Codex the skills are found under `.agents/skills`: type `$setup`, `$discover`, `$apply`, or `/skills` to list them. With any other agent, say what you want ("set this up", "find jobs", "apply to the best five") and it follows the same files.

The agent that runs the skills and the model that writes your answers are two separate choices. To write with something other than Claude, see [Works with](#works-with).

</details>

## Works with

| | |
|---|---|
| **Systems** | macOS, Linux and Windows. Linux and Windows are new: every test runs on all three in CI, with a real browser and each system's real secret store, but a full run on a Linux or Windows desktop has not been done by the maintainer yet. [docs/PLATFORMS.md](docs/PLATFORMS.md) says exactly what was and was not tried. |
| **Agents** | Claude Code (the default, through `CLAUDE.md` and `.claude/skills`). Codex and others through `AGENTS.md`. |
| **Writers** | Claude Code on your subscription (the default), the Claude API on your key, the Codex CLI on your ChatGPT plan, or any service that speaks OpenAI's chat completions, such as OpenAI, OpenRouter, or a model on your own machine through Ollama. One line in `.env`: [Choosing the writer](docs/SETUP.md#choosing-the-writer). Only Claude has been run on real forms. |
| **Job boards** | Greenhouse, Lever and Ashby by link or from the queue, and Workable, Rippling, BambooHR, Jobvite and JazzHR forms from the queue. Workday is [in progress](#jobs-that-want-an-account). |
| **Browsers** | The tool opens its own Chrome window with its own profile. Your everyday browser is not touched. |

## How it works

```mermaid
flowcha
````
