Contents
Role Reaper
A job-search engine that turns a candidate's profile into a ranked, tailored shortlist. It derives search terms from a resume, pulls real postings, scores each one against the candidate deterministically, and drafts tailored application materials. It never invents a qualification the candidate doesn't have. I built this one for my own job search, so the candidate it's tuned around is me.
Job search is repetitive work that punishes shortcuts
Finding the right roles means running the same searches over and over, reading past boilerplate, and judging each posting against your actual fit, then rewriting your materials for every one. It's slow. And the obvious automation shortcut is dangerous. Hand the whole thing to a language model and it will happily invent skills, inflate experience, and tailor a resume into something that gets you caught in the first interview.
Role Reaper automates the tedious parts and refuses the dangerous one. The model does the reading and the structuring. Deterministic code does the scoring. And the tailoring step is built so it physically cannot add a qualification that isn't already true.
Four stages, run and reviewed in order
The pipeline runs in deliberate stages, each one inspectable before the next. Terms are derived and reviewed before any postings are pulled; postings are scored before anything is tailored. Nothing happens in a black box you can't check.
Stage zero reads each resume variant and derives the job-title search phrases that would actually surface matching roles. Real titles employers post under, not skill keywords. Stage one pulls live postings for those phrases from a job-board API. Stage two scores them. Stage three tailors materials for the strongest matches.
Facts from the AI, scores from the code
Scoring a posting is where most AI tools quietly go wrong. They ask the model "is this a good fit?" and get a vibe back, a different answer each time, impossible to tune or trust. Role Reaper splits the job in two. The model's only role is extraction. It reads the posting and returns structured facts: which of the candidate's core skills are named, whether the role is remote or onsite, the experience level it asks for, whether it's a thin or boilerplate listing, whether it demands a credential the candidate lacks.
Then deterministic code turns those facts into a score against a fixed rule set. Points per matched skill. Modifiers for location, salary band, and experience fit. Hard penalties for postings that are junk or require credentials the candidate doesn't have. The same posting always scores the same way, the rules live in one place and can be tuned by editing numbers, and there's no model variance in the part that decides what's worth applying to. It's the same discipline I use everywhere. Let the model read and structure. Never let it be the thing that quietly invents a number.
Tailoring without lying
For every high-scoring role, the tool tailors the application, and this is where the anti-fabrication discipline is strictest. The resume bullets are stored verbatim, each tagged with the skills it demonstrates. To tailor a resume to a role, the tool reorders the bullets by how well they match that role's identified skills. It never rewords them, never embellishes, never writes a new accomplishment. The most relevant true things rise to the top. Nothing untrue is ever added.
The only place rewriting is allowed is the summary paragraph, the one part of a resume that's meant to be re-pitched per role, and even that is generated from the candidate's real positioning. A cover letter is drafted in a balanced voice from the same true material. The result is tailored, role-specific application materials I can send without a single claim I'd have to walk back.
Built to run in stages, and to fail safely
Each stage writes its output to disk (derived terms, pulled-and-scored results, tailored drafts) so the pipeline is inspectable and resumable rather than one fragile end-to-end run. You can review the search terms before spending API calls pulling postings, check the scored results before tailoring, and re-run any single stage without redoing the others. Credentials are checked up front, and a failed search for one term logs the error and keeps going instead of taking down the whole pull.
It runs behind a small local web interface as well as from the command line, so I can kick off a run and watch its progress without touching the code. The architecture is the same shape as the rest of my work. Discrete stages, sourced inputs, deterministic decisions, and failure handled out loud.
What it demonstrates
The same spine as everything I build. A language model used only for the judgment-light work of reading and structuring, deterministic code in charge of every decision that has to be reproducible, and an anti-fabrication rule enforced by construction rather than hoped for. A staged, inspectable pipeline that does real, repetitive work and refuses to lie to do it faster.
This one I built for myself, and that's the point of it. I could strip out the parts that are tuned to me and rebuild it as something other people could use. But right now its edge is that it's personal, fit to one real candidate and one real search. I wanted to show what I build when the only person I'm answering to is me.