It was not designed. It accreted.

Every version of this existed because the one before it hit a wall.

It started as one script. I was job hunting, and I was tired of typing the same answers into the same forms. Name. Work authorization. Desired salary. How did you hear about us. So I wrote something to fill one board's form for me. That was the whole idea. Then it kept hitting walls, and I kept going.

  1. It could not remember.

    One script has no memory of what it already did. So I gave it a database. Now it knew which postings it had seen and which it had already applied to.

  2. Pointing it at each job by hand did not scale.

    So it started reading the open roles off the job boards itself, instead of waiting to be told where to look.

  3. It applied first and judged afterwards.

    That is backwards. Applying first is how you send an application to a job you were never right for. So I turned it around: score first, apply only to what fits. That one change is why it says no far more often than it says yes — and the filtering turned out to be most of the value.

  4. Keyword scoring was not good enough.

    A résumé is not a bag of words. So a language model started reading each posting against my actual background and scoring the match properly.

  5. The cloud model was confidently wrong.

    I tried sending the hard calls to a hosted model. Then I measured it against about 6,100 real postings. It called 43% to 57% of them worth applying to, where the local model called under 2%. It was not close, so I deleted that path rather than let it apply to jobs on bad scores. Scoring runs on your own machine now, and only there.

  6. Forms kept asking things it had never seen.

    Guessing was not an option — a wrong answer on a real application is worse than no application. So it started logging every question it could not answer, learning it, and reusing that answer next time. It gets better the longer it runs.

  7. The boards are not alike.

    Greenhouse, Lever, Ashby and Workday each do it differently. So each one got its own handling, and each one is a file you can read.

Which is why you get the source.

None of that was planned up front. It grew the way real tools grow: one person solving their own problem, one wall at a time.

That is why this is sold as a working example rather than a course. A course would show you a clean system that never existed. This is the messy one that actually ran, with the walls still visible in the code.

It is still built and run by one person, doing his own job search with it. No support team standing behind a black box. You can read every line, and so can your agent.

The walls are the documentation

Comments in the source say why something is the way it is, and what it cost to find out. Those are the expensive part.

Nothing is hidden

Plain Python. Nothing compiled, nothing obfuscated. If you disagree with a decision in here, you can change it.

You will hit wall eight

There is a board we do not cover. When you reach it, the Builder tier is the one with the guide for teaching it a new site.

If you came to read the agent.

Some people buy this without intending to job hunt at all. It is a production agent that has run daily since May 2026, delivered as source you can read end to end.

Three things in here are worth the price on their own, if that is why you came.

It never free-runs a model over a form. Answers are resolved against a store of facts you supplied. A question with no matching fact gets a blank and a log entry, not a generated answer. That is an architecture that removes the failure mode instead of detecting it afterwards.

It learns from its own gaps. Every unanswerable question is logged, triaged and folded back in, so the next run is better than the last. You can watch the loop close in the data.

It is gated at the dangerous step. An agent that can act in the world needs a place where a human says yes. Ours is one explicit switch, off by default, with the risks printed above it.

You cannot prompt your way to this.

This is the whole of what arrives, counted on the copy that ships. Count it again yourself when it lands.

# in your own copy, after you unpack it
$ find . -name '*.py' | wc -l
$ find . -name '*.py' -exec cat {} + | wc -l
Measured 2026-11-16 on the shipping artifact.
Python files200
Lines of Python75,433
working code40,070
comments and notes27,368
blank7,995
Test files79
Shell runners39
Application platforms10

The 36% is the real number

More than a third of those lines are comments. That is not tidiness. They record what went wrong: why a threshold is 7 and not 8, which model was twenty to forty times miscalibrated and got deleted, what a single unscoreable row cost in GPU hours before anyone noticed.

An agent can write the 40,000

It cannot write the 27,000. Those lines only exist because this ran against real employers for months and kept failing in ways nobody predicted. Generating code is cheap now. Finding out which of it survives contact is not, and that is the part you are buying.