# How the Drafter Agent Works in AI Job Search: An 8-Step Technical Breakdown

> Discover how the drafter agent in AI Job Search works. It parses job postings, generates LaTeX CVs, and creates ATS-optimized PDFs in 8 technical steps. Optimize your job applications now.

- Repository: [Mads Lorentzen/ai-job-search](https://github.com/MadsLorentzen/ai-job-search)
- Tags: deep-dive
- Published: 2026-07-20

---

**The drafter agent is the first Claude Code agent that parses job postings, generates tailored LaTeX CVs and cover letters from your candidate profile, and orchestrates a structured review loop to produce ATS-optimized PDFs.**

In the MadsLorentzen/ai-job-search repository, the drafter agent serves as the core engine behind the `/apply` command. This specialized agent transforms raw job descriptions into polished application materials by coordinating with a secondary reviewer agent through a token-efficient, file-based workflow defined in [`.claude/commands/apply.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/commands/apply.md) and documented in the repository's core workflow section.

## The Drafter Agent's Role in the `/apply` Pipeline

The drafter agent initiates the application process during the `/apply` command execution. According to the repository's README, it is the first of two specialized Claude Code agents responsible for creating the initial application deliverables—specifically the `cv_draft.tex` and `cover_letter.tex` files.

The agent operates under strict constraints defined in [`.claude/commands/apply.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/commands/apply.md) and relies exclusively on immutable source files including:
- **[`.claude/skills/job-application-assistant/01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/skills/job-application-assistant/01-candidate-profile.md)** (source of truth for all factual claims)
- **`cv/main_example.tex`** (CV template)
- **`cover.cls`** (cover letter template)

## Step-by-Step Workflow of the Drafter Agent

### Step 1: Parse the Job Posting

The drafter receives the raw job posting—either via URL or pasted text—and extracts required skills, responsibilities, and hard constraints. This parsing logic follows the specifications outlined in README.md (lines 25-27), ensuring no critical requirements are missed before generation begins.

### Step 2: Evaluate Fit Against the Candidate Profile

Using the evaluation rubric defined in [`.claude/skills/job-application-assistant/04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/skills/job-application-assistant/04-job-evaluation.md), the agent scores the posting against the user's profile. This step ensures the drafter only proceeds with high-quality matches and understands which specific experiences to emphasize in the drafts.

### Step 3: Generate LaTeX Drafts

The drafter populates the active LaTeX templates (`cv/main_example.tex` for the CV and `cover.cls` for the cover letter) with data from [`01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/01-candidate-profile.md). It produces two files in memory:
- `cv_draft.tex`
- `cover_letter.tex`

These drafts remain in the agent's working memory rather than being written to disk immediately, enabling efficient string manipulation during the revision phase.

### Step 4: Inline Hand-off to the Reviewer Agent

Rather than saving drafts to disk for the reviewer to read, the drafter embeds the full text of both LaTeX files **inline** within the reviewer agent's prompt. As specified in [`.claude/commands/apply.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/commands/apply.md) (lines 97-103), this **inline hand-off** saves tokens and guarantees the reviewer works on the exact version the drafter just produced.

### Step 5: Reviewer Critique and JSON Feedback

A fresh Claude Code reviewer agent researches the target company and returns **structured feedback** formatted as a JSON array of concrete edits. According to the apply command specification (lines 151-160), each edit object includes:
- `file`: The target filename
- `old_string`: Exact text to replace
- `new_string`: Replacement text
- `reason`: Classification (e.g., "grounding", "formatting", "keywords")

### Step 6: Apply Structured Edits Using the Edit Tool

The drafter consumes the JSON edit list and applies each change to the in-memory drafts using the `Edit` tool. Because the drafts never left memory, the drafter can safely execute exact string replacements without re-reading files from disk. This process is documented in [`.claude/commands/apply.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/commands/apply.md) under "Apply Part A (structured edits)" (lines 182-191).

### Step 7: Compile LaTeX and Verify PDF Constraints

After revisions, the drafter compiles the LaTeX files using `lualatex` for the CV and `xelatex` for the cover letter. It then runs an optional **ATS-check** using `pdftotext` to verify text extraction quality. The verification loop ensures the final output meets strict page limits: **2 pages maximum for the CV** and **1 page for the cover letter**, as noted in README.md (lines 36-39).

### Step 8: Present Final Output

The polished PDFs, accompanied by a verification checklist, are presented to the user as the final deliverables of the `/apply` command.

## Technical Implementation: The JSON Edit Contract

The communication protocol between drafter and reviewer relies on a strict JSON schema. The reviewer returns edits in this format:

```json
[
  {
    "file": "cv_draft.tex",
    "old_string": "Senior Data Scientist at Acme Corp (2020-2023)",
    "new_string": "Senior Data Scientist at Acme Corp (Jan 2020 – Mar 2023)",
    "reason": "formatting"
  },
  {
    "file": "cover_letter.tex",
    "old_string": "I have extensive experience with Python.",
    "new_string": "I have 5 years of experience building data pipelines in Python.",
    "reason": "grounding"
  }
]

```

The drafter validates each edit against the in-memory document state before applying it via the `Edit` tool, ensuring atomic updates and preventing partial application failures.

## Running the Drafter Agent

To trigger the complete drafter-reviewer pipeline with a live job posting:

```bash
/apply https://jobindex.dk/job/1234567

```

The command automatically executes all eight steps, from initial parsing through PDF verification. The drafter handles the entire orchestration, including spawning the reviewer agent and processing its feedback, without requiring manual intervention.

## Summary

- The **drafter agent** is the primary Claude Code agent in the `/apply` command that generates LaTeX application documents.
- It sources all factual claims exclusively from [`.claude/skills/job-application-assistant/01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/skills/job-application-assistant/01-candidate-profile.md) and template files.
- The **inline hand-off** mechanism passes draft content directly to the reviewer agent without intermediate file writes, optimizing token usage.
- Reviewer feedback follows a strict **JSON edit list** format that the drafter applies using the `Edit` tool on in-memory documents.
- Final compilation uses `lualatex` (CV) and `xelatex` (cover letter) with automated ATS verification and strict page constraints.

## Frequently Asked Questions

### What is the difference between the drafter agent and the reviewer agent?

The **drafter agent** generates the initial LaTeX files and executes revisions, while the **reviewer agent** provides independent fact-checking and quality control. The reviewer researches the company and returns structured JSON feedback, but does not modify files directly—the drafter applies all edits.

### How does the drafter agent achieve token efficiency?

By embedding the full LaTeX draft content **inline** in the reviewer prompt rather than writing files to disk and requiring the reviewer to read them, the system avoids redundant token consumption. This **inline hand-off** pattern ensures the reviewer sees the exact draft state while minimizing context window usage.

### Which source files does the drafter agent read during execution?

The drafter reads the candidate profile from [`.claude/skills/job-application-assistant/01-candidate-profile.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/.claude/skills/job-application-assistant/01-candidate-profile.md), evaluation criteria from [`04-job-evaluation.md`](https://github.com/MadsLorentzen/ai-job-search/blob/main/04-job-evaluation.md), and LaTeX templates from `cv/main_example.tex` and `cover.cls`. All factual claims in the final documents must be traceable to these immutable source files.

### What LaTeX engines does the drafter agent use for compilation?

The drafter uses **`lualatex`** to compile the CV and **`xelatex`** for the cover letter. This dual-engine approach ensures optimal font rendering and layout fidelity across both documents before the final ATS compliance check.