Why a Resume is an Empirical Technical Proof, Not Creative Writing
Most people treat resume tailoring like an exercise in fiction. You find a job description, see what buzzwords they want, and spend hours massaging your past work until it roughly matches their phrasing.
When generative AI arrived, that bad habit accelerated. Tools popped up claiming to “tailor your resume in seconds.” In practice, that meant running an unconstrained prompt which made LLMs invent scale, sprinkle in Kubernetes, and fabricate metrics you never touched.
Let’s be clear: a resume was never a creative writing endeavor, it has always been an empirical technical proof. Not that you should be using LLMs for creative writing anyway, but that’s a gripe for another day.
If you claim you scaled an event pipeline to 10M daily events, that is a verifiable engineering claim. If you get past an automated screen by lying, the illusion collapses ten minutes into the technical interview when a staff engineer asks you how you handled backpressure, consumer rebalancing storms, or network partition edge cases.
Faking experience doesn’t get you hired. It just guarantees you fail in front of a real engineer instead of an automated parser.
| The Probability Problem (Unconstrained Chatbot) | The Breadwinner Fix (Grounded Pantry Engine) |
|---|---|
| Input: “Make me look senior” | Input: Verified JSON career vault |
| Search Space: High entropy, broad sampling | Search Space: Zero entropy, strict schema |
| Mechanism: Probabilistic hallucination | Mechanism: Deterministic indexing compiler |
| Content: Invented scale, buzzword slurry | Content: 100% verified facts, real metrics |
| Outcome: Fiction | Outcome: Technical proof |
The Math: How Rich Context Tames Probability
At a fundamental level, language models are probabilistic next-token predictors. The generation of each token is conditioned on prior context:
When you hand an LLM a thin, two-paragraph summary and ask it to “tailor this for a Staff Systems Engineer role,” the prompt context is sparse. The model faces high entropy across its vocabulary. Because the probability distribution over possible completions is broad, the model bridges the gap with statistical averages. In tech recruitment, those averages look like generic corporate slop: “drove synergistic paradigm shifts.”
To get deterministic output from a probabilistic model, you must drastically constrain the sample space.
In technical terms, conditioning the model on dense, exhaustive ground truth (exact throughput figures, latency measurements, architecture trade-offs, and toolchain configurations) collapses the entropy of the conditional distribution. The probability mass concentrates entirely on your actual achievements.
The LLM stops guessing. It transitions from an open-ended creative fiction generator into an indexing compiler. It selects and formats real accomplishments that match the target spec.
The Privacy Problem: The Career Ledger Exposure
That leads directly to the privacy issue.
To make an LLM behave deterministically, you need to give it deep, personal context: not just public portfolio links, but internal project scale, private compensation targets, visa constraints, notes on why you left past teams, and unreleased architecture details.
That is your career ledger. It is some of your most sensitive personal and professional data.
Handing that raw, evolving ledger over to random cloud-hosted resume wrappers creates massive exposure. Their databases get breached, their API logs retain prompts for model fine-tuning, and your private notes become training fodder.
When I started building Breadwinner, I locked in the following principles:
-
Deterministic Grounding (Zero Hallucinated Experience): We don’t rely on fuzzy prompt promises like “please don’t lie.” Breadwinner hard-constrains the LLM through deterministic schema verification against a local vault called the Pantry. The Pantry holds your raw profile in the JSON Resume standard. If a role demands three years of Rust experience and it does not exist in your Pantry, Breadwinner’s compiler rejects the hallucination and flags the gap instead of letting the model smooth it over.
-
Strict Metric Preservation (The Google XYZ Formula): Generic AI tools routinely dilute technical impact. Breadwinner forces every bullet point to adhere to Google’s XYZ formula:
Accomplished [X], as measured by [Y], by doing [Z].
If you reduced p99 latency from 120ms to 79ms, that exact measurement is preserved. The LLM is allowed to format your real accomplishments against what the job spec cares about. It is never allowed to fabricate or dilute the outcome.
- Complete Local Custody (BYOK): Career data belongs on your own machine. Breadwinner runs locally in your terminal, communicating with local models via Ollama or LM Studio on localhost, or directly to your own API keys. No external accounts, no cloud databases, zero telemetry.
The Agentic Loop Tax: Paying Cloud Wrappers to Leak Your Career
To make matters worse, the current industry meta is over-engineering this with bloated “agentic loops.”
Instead of a clean, single-pass compiler, modern tools bounce your private career history back and forth across a multi-agent swarm making dozens of external API calls. They charge you a hefty monthly markup to execute what is fundamentally a deterministic indexing problem.
Do you really want an opaque 10-turn cloud agentic loop churning over your salary targets, visa constraints, and unreleased architecture notes? An agentic loop doesn’t just cost more; it multiplies your data leak surface area with every external turn.
Resume tailoring doesn’t need an autonomous swarm. It needs a fast, deterministic local compiler.
By treating the resume as an immutable proof rather than a creative writing prompt, tailoring stops being a game of guessing keywords. It becomes a clean compiler job: take verified facts, match them against job requirements, and output a print-perfect PDF that you can defend in any interview.
(Next up: what happened when my ingestion engine accidentally deleted 4 years of my Deloitte experience).