pip install applyr && applyr init && applyr setup-agent

[!NOTE] Requires Python 3.11+ and an AI coding agent (Claude Code, Cursor, OpenCode, or any agent that reads instruction files).

How it works

You: paste a job offer into your AI agent

         |
         v

Agent: reads cv-master.md + evaluates 6 topics
       runs  applyr add '<json>'

         |
         v

applyr:  82% compatibility (>= 80% threshold_apply)
         >> RECOMMENDATION: APPLY
         Skill gaps: English, Experience

         |  (you confirm)
         v

Agent: blind recruiter evaluation (applyr cv review-blind)
       generates CV with tailoring plan (applyr cv generate)
       └─ plan auto-created: evidence map, priorities, forbidden claims
       applies plan to fill CV skeleton from cv-master.md
       verifies every claim (applyr cv verify) — PASS
       checks ATS compatibility (applyr cv ats-check)
       delivers PDF ready to send

applyr is the storage layer. Your AI agent is the brain.

The CV tailoring pipeline flows through structured roles:

Matcher  →  Recruiter  →  CV Architect  →  CV Writer  →  Fact Checker  →  Final
(fit)       (quality)      (plan)          (execute)      (verify)

Each role reads the previous output — no information is lost between steps.

Features

• Three-state recommendation — APPLY (>=80%), MAYBE (60-79%), LOW MATCH (<60%) with configurable thresholds
• Skill-level breakdown — Strong/Partial/Missing per topic with icons (✓/△/✕)
• "Why you match" — Executive summary of strengths and weaknesses
• Weighted scoring — 6 configurable topics (tech stack 35%, experience 35%, projects 15%, education 5%, english 5%, cultural fit 5%), with a per-offer weights_used snapshot so rescore and future rebalances never corrupt historical scores
• Score breakdown — Weighted contribution per topic so you understand why 78%
• CV tailoring plan — automatic evidence map per requirement (STRONG/WEAK/MISSING), priorities (P0-P3), forbidden claims, and section strategy — generated on cv generate, saved to DB
• Claim-grounding gate — cv verify checks every technology, metric, and employer name in a generated CV against your cv-master.md, deterministically — no LLM call, exit 0 (PASS) or 1 (BLOCKED, lists unsupported claims). JSON output includes evidence density metric and Fact Checker-compatible issue format
• Agent role instructions — dedicated .md files per role (Matcher, Recruiter, CV Architect, Fact Checker) in applyr/templates/agents/, referenced from the main agent instructions
• Duplicate detection — same company+title? applyr catches it before you waste time
• ATS-safe CVs — locked single-column CSS, standard fonts, no images. Your agent fills content, never touches structure
• ATS compatibility check — validates CV against ATS rules (headers, formatting, keywords)
• Keyword extraction — pulls keywords from job offers and matches against your CV
• Bullet point optimization — analyzes weak verbs, suggests strong alternatives, detects missing metrics
• Cover letter generation — tailored letters from your profile + offer data
• CV comparison — compare two CV versions (ATS compatibility score delta, keyword coverage)
• Recruiter review — built-in prompt scores your CV 0-100 with specific improvements
• Response rate tracking — measure application performance with monthly trends
• Score calibration — applyr stats reports real response/interview rates per score band, so you can see whether a higher compatibility score actually predicts a better outcome
• Confidence + evidence — score each topic with a high/medium/low certainty and a justification; add/show surface both, so a score is never just a bare number
• 28 commands — pipeline, stats, gaps, trends, salary insights, follow-ups, compare, rescore, export, and more
• Local and private — SQLite on your machine. No API keys, no subscriptions, nothing leaves your system
• Agent-native — ships with AGENT_INSTRUCTIONS.md that tells Claude/Cursor/OpenCode exactly what to do

Quick start

1. Install and initialize

pip install applyr
applyr init

This creates ~/.applyr/ with config, database, and agent instructions, plus a starter cv-master.md in ~/Documents/applyr/ — outside the dotfile since you edit it by hand often.

2. Fill your profile

Edit ~/Documents/applyr/cv-master.md with your complete professional profile. This is the only source of truth — the agent reads it to score offers and write CVs.

3. Connect your agent

applyr setup-agent                       # Auto-detects Claude/Cursor/OpenCode
applyr setup-agent --agent claude        # Or specify: claude | cursor | opencode | generic

Done. Paste a job offer into your agent and say "analyze this".

What your agent sees

You:   "Analyze this AI Engineer posting at Acme Corp"

Agent: Checks duplicates → none found
       Scores: tech_stack 85%, experience 40%, projects 90%...
       applyr add '<json>'
       → "82% match. APPLY recommended. Generate CV?"

You:   "Yes"

Agent: applyr cv generate 1 → fills from cv-master.md
       applyr cv review → ATS compatibility score: 87/100, READY TO SEND
       applyr cv verify → PASS, every claim grounded in cv-master.md
       applyr cv pdf → delivers PDF

You:   "Analyze this Data Analyst role at SmallCo"

Agent: applyr add '<json>'
       → "42% match. SKIP recommended. Gaps: no R/Tableau, 0 data roles."

You:   "What should I learn?"

Agent: applyr gaps → "Experience: seen in 15 offers, avg gap 20%"

Commands

Tracking

applyr add '<json>'                # Register offer (agent builds the JSON)
applyr list [--status S]           # All offers or filtered
applyr show <id>                   # Full detail + topic scores
applyr pipeline                    # Grouped by status
applyr update <id> <status>        # Change status, add notes
applyr delete <id>                 # Remove an offer
applyr search <keyword>            # Search by company/title/tech
applyr search --company <name>     # Exact company match (same definition add uses for duplicates)

Analytics

applyr stats                       # Conversion funnel + metrics
applyr gaps                        # Skills to improve (by frequency)
applyr trends                      # Applications per week
applyr summary --json              # Weekly summary for LLM
applyr compare 1 3 4               # Side-by-side offers
applyr rescore <id>                # Recompute compatibility_pct under current weights
applyr plan                        # Learning priorities
applyr salary [--seniority mid]    # Salary insights
applyr followups                   # Overdue + upcoming

CV pipeline

applyr cv generate <id>            # Markdown CV with YAML frontmatter
applyr cv review <file.md>         # Recruiter review prompt (accepts .md or .html)
applyr cv review-blind <id>        # Independent CV evaluation (no score bias)
applyr cv verify <file.md>         # Deterministic claim-grounding gate (no LLM, exit 0/1)
applyr cv pdf <file.md>            # Markdown → ATS-HTML → PDF via Chrome
applyr cv ats-check <file.html>    # Check ATS compatibility (0-100 score)
applyr cv keywords <id>            # Extract & match keywords vs CV
applyr cv bullet-optimize <file>   # Analyze bullet points (weak verbs, metrics)
applyr cv cover-letter <id>        # Generate tailored cover letter
applyr cv compare <v1.html> <v2.html>  # Compare two CV versions
applyr cv stats                    # CV performance analytics

Response tracking

applyr response-rate               # Application response rate + trends

System

applyr doctor                      # Health check
applyr export --format json        # Export everything
applyr version                     # Show version

Scoring

Each topic is scored 0-100 by the AI agent, then weighted:

Formula: sum(score * weight) / sum(weights) — configurable in ~/.applyr/applyr.toml.

Every offer stores a weights_used snapshot of the weights that actually produced its score, so changing [weights] later never corrupts the meaning of scores already stored. Run applyr rescore <id> to recompute one offer's score under the current weights; use applyr show <id> to see which weights produced any offer's stored score.

Thresholds: score >= 80% → APPLY, 60-79% → MAYBE, below 60% → LOW MATCH. Configurable via threshold_apply/threshold_maybe in applyr.toml.

Status flow

pending ──> applied ──> waiting ──> in_process ──> offer
               |            |           |
               v            v           v
           discarded    rejected    rejected

Configuration

# ~/.applyr/applyr.toml

[general]
threshold_apply = 80    # Score >= this → APPLY
threshold_maybe = 60    # Score >= this → MAYBE (below → LOW MATCH)
followup_days = 10      # Days before follow-up reminder

[weights]               # Auto-normalized, no need to sum to 1.0
tech_stack = 35
experience = 35
projects = 15
education = 5
english = 5
cultural_fit = 5

Project structure

applyr/
  cli.py                 # Entry point
  config.py              # TOML config
  db.py                  # SQLite schema (offers: 36 columns, 6 tables)
  scoring.py             # Weighted scoring engine + CV_TAILORING_PLAN builder
  cv.py                  # Markdown CV + Chrome PDF + recruiter review
  evidence.py            # Deterministic claim parsing (parse_evidence, is_evidenced)
  ats.py                 # ATS compatibility checking + keyword matching
  analytics.py           # CV comparison + response rate tracking
  md_render.py           # Narrow markdown → ATS-HTML converter
  commands/
    core.py              # add, list, show, update, delete, search, init, setup-agent
    analytics.py         # stats, gaps, trends, pipeline, compare, plan, salary
    workflow.py          # export, doctor
  templates/
    AGENT_INSTRUCTIONS.md  # Main agent dispatcher (references agent roles)
    agents/
      matcher.md         # Matcher role: evaluates offer fit
      recruiter.md       # Recruiter role: blind CV evaluation
      architect.md       # CV Architect role: builds tailoring plan
      fact_checker.md    # Fact Checker role: verifies claims
    ats_rules.json       # ATS validation rules
    bullet_patterns.json # Bullet optimization patterns
    cover_letter.md      # Cover letter template
tests/
  test_tailoring.py      # Evidence evaluation + tailoring plan tests
  test_cli_routing.py    # CLI router coverage
  test_cv.py             # CV pipeline tests
  test_ats.py            # ATS compatibility tests
  test_analytics.py      # Analytics tests
  test_cv_bullets.py     # Bullet optimization tests
  test_cover_letter.py   # Cover letter tests
  test_md_render.py      # Markdown renderer tests
  test_db.py             # Schema + migration tests
  test_scoring.py        # Scoring engine tests
  test_config.py         # Config loading tests
  test_validators.py     # Input validation tests
  ...

Development

git clone https://github.com/DeibyGS/applyr.git
cd applyr
pip install -e ".[dev]"
pytest                             # 828 tests, ~5s

Built with AI

applyr was designed to work for AI agents — it made sense to build it with one, as a pair programming partner.

Process: Spec (SDD) → AI implementation → Human review → Test → Merge

License

MIT — use it, fork it, improve it.