Project Snapshot
Half of job searching is routine: refreshing boards, decoding titles, checking location and seniority fit. I built a system to take that work off my hands. Every morning it scans more than 100 target companies through their recruitment platform APIs, filters and scores what it finds, and pushes anything worth my attention to Slack.
Since August, it also reads back what happens after I apply: every application is tracked from send to outcome. Built in three stages: a no-code proof, a rebuild on ATS APIs, and a measurement loop once sourcing turned out to be the easy half. The design question underneath: which judgments belong to rules, which to AI, which stay with me, and how do I know they were right.
Result
Running daily since March 2026, rebuilt once along the way, and instrumented end to end since August.
99%
Of postings resolved by rules before any AI call
3 layers
Rules, model, human: where judgment lives
End to end
Every application tracked from send to outcome. Ongoing.
Why Build My Own
Two things pushed me to build rather than adopt.
The first was where the data comes from. Job boards and company career pages don't stay in sync. Roles appear on a company's own page before an aggregator indexes them, and stay listed on boards after they have closed. Collecting from boards means waiting on someone else's index, so I went to the source instead: pick the companies I care about, and watch their career pages directly.
The second problem only showed itself after the first was solved. The moment a CV is sent, it enters a dark tunnel. Somewhere along screening, portfolio review, hiring manager, whiteboard, panel, the process dies, and nothing marks the spot. Rejections arrive as templates, when they arrive at all. In design and research hiring the tunnel is long: the late stages at least leave a scent of why you failed, but the early ones, CV and portfolio, end in silence. You can experiment, and I did, but without data every experiment ends the same way: a feeling, not a conclusion.
I had automated my sourcing and was still guessing at everything after send. So I did what a researcher does with an unobservable system: I instrumented it.
From Proof, to Rebuild, to Loop
V1: proving the concept in no-code
V1 was built in Make with one goal: test whether AI could genuinely share the screening work. One pipeline scanned job board RSS feeds, scored roles with AI and pushed a daily digest to Slack. The proof held at minimal build cost: AI judged relevance reliably, and the daily push changed how I browsed jobs.
Three months of use exposed the ceiling. The RSS sources skewed to remote roles and missed my real market, the data store kept forgetting what it had seen, and the CV advice ran too shallow to use. I tried repairing it, but the capability I wanted most, watching target companies directly, could not be built on that platform. The ceiling was the platform, not the configuration.
Rebuild, and reverse the approach
So I killed it and reversed the strategy: no more wide nets across job boards. V2 watches my target companies directly, through their recruitment platform APIs. The list is mine, the criteria are mine; the system's only job is to bring me what changes across those companies each day.
The automation I refused
After the rebuild, the obvious next automation was the application itself: batch-tailored CVs, auto-submission. I refused both, though not because AI is kept away from my CV. Every CV is tuned with AI, in a working session about how my story should meet that JD.
What I refused is the batch version: a pipeline rewriting claims I would then have to defend in interviews, and submissions no one actually judged. Whether a company deserves an application is the one judgment this system exists to protect. What the tunnel needed instead was observation. So the third phase pointed the engineering at the dark half of the funnel: not automating my decisions, but instrumenting whether they were working.
How It Works Now: Two Engines
The system is now two engines around one funnel.
V2 is a Python system built with Claude Code, running daily on GitHub Actions.
The flow fits in one sentence: query more than 100 companies' ATS APIs, filter the obviously irrelevant with rules, let AI read the full description and score the rest, and push anything above threshold to Slack. I am not an engineer, and it never became a blocker: I set direction, judged output and vetoed what was wrong; Claude Code implemented.
The observability loop answers the other question: what happens after I press send?
Every CV carries a UTM-tagged portfolio link recording which positioning it argued: researcher, product designer, or ops. GA4 shows whether the hiring side opened the portfolio and what they actually read. A script scans my own mailbox and rebuilds the funnel stage by stage: applied, screening, hiring manager, panel, offer, rejection. A weekly job runs the analysis and pushes it to Slack, with sample-size rules deciding what the report is allowed to claim.
Where Judgment Lives
What can be written as a rule goes into code?
Location range, title tier, excluded keywords, and the language the description is written in: these judgments need consistency, not intelligence. The rule layer absorbs 99% of all volume at zero cost, before anything reaches AI.
Language turned out to be the clearest case. A German or French posting routinely carries a fully English title, so the title has no resolution here; the rule had to read the description instead. Not every rule that lacks resolution needs AI. Some just need better data.
What requires reading context goes to AI?
What a role actually involves, and whether it genuinely fits, can only be judged from the full description; no rule can express that. Titles like content strategist can mean embedded product content or marketing copy. Claude Code suggested dropping the ambiguous keyword; I chose to keep it and push the judgment down to the AI layer, where the context lives. When a rule lacks resolution, move the judgment, not the coverage.
The final decision stays with me 🌟
Whether to apply is always my call. A score can tell me a role matches on paper. It cannot tell me whether the company's culture fits, whether I want to work on that kind of product, or whether I should reach out to someone there before applying. Those are the judgments worth my time, and they are why the system ends at my Slack rather than at a submitted application.
About one in eight of the companies I watch cannot be fetched automatically. Rather than force a scraper, I settled on a weekly manual check with an automated reminder. Not everything deserves automation; maintenance cost is a design consideration too.
The Numbers, and What They Changed
Rules absorb 99% of everything the system sees. Around 1% is worth an AI read, and under 1% reaches my Slack.
Rules run free; AI is spent only where judgment is genuinely required. Ratios from daily runs since the July 2026 rebuild. As of 28 August 2026: 20,441 roles processed, 189 scored by AI, 137 surfaced to Slack.
Three instruments, each lighting one stretch of the tunnel.
UTM tagging lights the mouth: did this application get the portfolio opened, and under which story?
GA4 lights the middle: once inside, did they read or bounce?
The mailbox scan lights the far end: at which stage does the process actually die?
None of it demanded new behaviour from me. The links were already being sent, the confirmation emails already arriving; the loop only made them legible. The strictest rule is the reporting one: below the sample floor, the weekly report states counts and refuses conclusions.
What the loop has surfaced so far, and what changed:
Its first catch was itself. I was tracking portfolio opens with no denominator: no record of how many applications had gone out. The fix became a mailbox scanner that rebuilt eight months of funnel history. Every ratio now has a floor under it.
My flagship case was being opened, not read. Engagement ran at seconds against a seven-minute expected read. The rewrite queue is now ordered by reading data instead of by which case I am proudest of. Ongoing.
The three CV framings perform differently. The product-designer story draws most of the portfolio opens; the researcher story has stayed nearly silent. Samples are small, so the report treats this as a signal to keep testing, not a verdict. My general-application narrative already leans on the stronger framing. Ongoing.
Outcome
V2 fully replaced V1 in July 2026, and the loop closed over it in August.
The funnel is no longer dark: every application since August reports back, the rewrite queue takes orders from reading data, and the next iteration of the CV starts from evidence instead of a feeling. The loop is young, and most of what it says today is "keep testing". Ongoing!!
Reflection: AI filters, I judge and decide
Designing an AI system is deciding where judgment lives.
Misplacing any layer carries a cost: context judgments forced into rules kill good candidates, rule judgments handed to AI waste money, and human decisions handed to the system destroy trust. The judgment map is now the first thing I draw.
Automation without measurement is faster guessing. The agent decides where judgment lives; the loop shows where it was right, and its first catch was a hole in itself. Instrumentation is not a feature you add to a system: it is what turns a system into something you can study.
The project also tested a working method: I owned direction, acceptance criteria and the veto; AI owned implementation. That division has become my default way of leading technical builds.
