P.I.P.E.R.

P.I.P.E.R.

Designing an AI co-pilot for the job search

Module one, the pipeline: every application is one path from where it came from to where it ended up (sample data)

P.I.P.E.R. is a privacy-first co-pilot for the job search that runs entirely on your own computer. It reads your inbox, drafts your outreach and prepares your applications, and never acts without you. The first module is built and in daily use; the rest are designed or planned.

Role
Product designer and engineer, solo, end to end
Constraints
Fully local, one 8 GB consumer graphics card, read-only access to a personal inbox
Status
Inbox pipeline and analytics built, pipeline in daily use. Writing fully specified. Résumé, interview prep and applying planned.
Source
github.com/k17n/piper

The problem

A job search is five jobs at once: knowing where you stand, writing to people, telling your story, preparing for conversations, and applying. Each happens in a different place, and none knows what the others know. I started from my own routine, then talked to a few friends who are job-hunting and read what people ask for on Reddit and X. It was informal, not a research study.

Tracking
Gmail and LinkedIn, checked by hand.
Writing
Cover letters drafted with ChatGPT.
Résumé
One PDF for every role type (design, product, VC, startup generalist). None tailored.
Interviews
No AI help, though it would be useful.
Applying
By hand. I don’t trust an AI co-pilot to do it.

Two requirements follow. Context has to carry across steps, so the inbox can inform a draft. And the barrier is trust, not capability: I would take help with writing and prep, but I won’t let anything press submit. Both drive the decisions below.

Decision 1: run it on your own machine

Tracking applications means reading the inbox, which also holds bank and tax mail, medical messages, password resets and private conversations. A hosted service asks you to trust a company you can’t inspect with all of it: where it is stored, who can read it, and whether it trains models or ends up in a data product. So the model runs on your machine and your mail doesn’t leave it.

Model
Qwen 2.5 7B through Ollama on an 8 GB graphics card. No email text goes to an AI service.
Stored
Short snippets, plus an excerpt for emails in the review queue, and short generated summaries made from counts, never from email text. Full conversations are fetched live and never saved.
Network
Gmail, read-only, so it can’t send, delete or change a message. One other call: fetching a job posting, only when you click “Fill from link”.
Access
Listens on your machine only. No account, and no server of mine in the middle.

Why. A privacy policy is a promise. A program with no route out is a property you can check, and the code is open source under the MIT license, so anyone can fork and host it. The search is also often private from a current employer, so a leak costs more than any accuracy a bigger hosted model would add. Local also lets the co-pilot use the whole thread and your real stories, which I would hesitate to ask of someone else’s server.

Cost. Setup is heavier than signing in to a website, and a 7B model is weaker than a hosted one. I treated that as a design input: the product assumes the model will sometimes be wrong, so it shows evidence and asks when unsure (decision 3). Away from your desk, a private network such as Tailscale can connect your own devices to your machine, and nothing is exposed unless you set it up.

Decision 2: a ladder of autonomy, capped at “prepare”

How much should a co-pilot do, and how does it earn the right to do more? Each step is earned by being right at the one below.

1 · Observe
Reads and organises. The inbox becomes a pipeline. Built.
2 · Suggest
Proposes with evidence; you decide. Review queue and suggested memories. Built and designed.
3 · Draft
Produces work to review, showing its sources. A cover letter with “claims to check”. Designed.
4 · Prepare
Does the legwork; you press the button. Planned.
5 · Act alone
Acts unprompted. Ruled out: it never sends or submits.

I stop at level 4. Everything a person’s name goes on stays their decision, the same line I draw in my own search. Every module shares three things: the company thread, your knowledge base (plain files on your machine), and memory that changes only with your approval.

Decision 3: ask, don’t guess

Problem
Some emails are ambiguous: a rejection that never names the role, two roles at one company, a scheduling note with no context. A confident wrong answer is worse than a spreadsheet, because you can’t tell which one was wrong.
Decision
If the model is unsure, can’t parse its own answer, or lacks a company or stage, the email goes to a review queue, not the pipeline. A card shows the reason, sender and excerpt, with a quick-fix form prefilled with the model’s guess. Merging is cautious: close company and role matches combine (“Initrode via Greenhouse” joins “Initrode”), but different seniority levels and different roles stay separate.
Why
A wrong merge is silent and spreads. A question is visible and small.
Cost
It isn’t hands-off. On six months of my own inbox, identical confirmation emails merged into one application, and the queue only works if it stays small, so I tuned thresholds until about 1% of emails reached me.
A rejection that never says which role it is for. Instead of guessing, P.I.P.E.R. asks (fictional data)

Decision 4: conclusions are derived, never stored

Problem
Silence is ambiguous. A company that hasn’t replied may have ghosted you, or may just be slow.
Decision
“Ghosted” is a suggestion, not a verdict. It is worked out when you look: no reply for 30 days and no final outcome. A later email reverses it. You can also set a stage by hand, and that holds until you clear it.
Why
A stored conclusion turns a guess into history. A derived one can be overridden, undone and improved without breaking anything.

Decision 5: one dataset, several ways to read it

I search design, product and VC roles in parallel, so the same data has to answer different questions.

Saved views
Save any mix of date range, role type, source, stage and search as a named view. Switching between “design roles” and “VC roles” is one click, and one view opens by default. Built.
Funnel and table
The funnel shows where applications come from and where they end up, with response, interview and offer rates and median days to a first reply. The table handles individual applications. One set of filters drives both, so the totals agree. Built.
Analytics
The funnel shows where applications ended up. Analytics shows effort and mix over time: applications per day with a 7-day average and streak, role type, source and seniority mix, an activity heatmap, and response rates by those same groups. It follows the same filters and saved views, so its totals match the other tabs. Built.
Kanban
Stage columns where dragging a card sets the stage. The funnel answers “how is my search going”; lanes answer “what needs me today”. Coming soon.
One thread
Each application keeps its timeline and full conversation in one place, with every event linking to Gmail. Messages from another application are hidden. Built.
Gaps
Referrals and phone screens never reach email, so they go in through a light manual form, and later emails attach to that entry instead of duplicating it.
Saved views: a named set of filters, with one opened by default. The role, source and stage filters sit beside it (fictional data)
Analytics: six summary tiles, a written summary from the local model, and applications per day with a 7-day average. One of several generated summaries (fictional data)
The company thread: every email that moved the application forward, above the live conversation, newest first. This is the context the writing module will draw on (fictional data)

Decision 6: the app calculates, the model only describes

Problem
A funnel shows where applications ended up, not how much you apply, to what, or what is working. A written summary is quick to read, but a language model that does its own arithmetic can be confidently wrong, and a 7B model is a weak statistician.
Decision
The backend works out the notable facts: the largest mix shares, the best and worst reply rates among groups of five or more, pace against the previous period, and whether recent weeks are still waiting for replies. The model gets only those as short labelled lines, and every number it writes must appear in them. If one doesn’t, it retries once and then says no summary could be written, without listing the facts instead. With under 10 applications it says there isn’t enough data and calls no model. It describes patterns and never gives advice.
Why
Every claim in the summary can be checked against the tiles and tables beside it, and a wrong figure can’t pass. The summary also costs little to run: it writes itself once the numbers have been still for 10 seconds, never during a sync, and is cached against its facts, so editing a note triggers no model call.
Cost
The check covers digits, not wording. In my test runs on sample data, the 7B model sometimes misread a median as a “longest” time or ranked a lower rate above a higher one. So the card says it is written by the local model, a refresh control writes it again, and the screenshot above is one of several generations.

The same caution applies to the numbers themselves. Every rate shows its count beside it, groups under five applications are muted and marked “small sample”, and the weekly response chart draws the latest two weeks dashed, because replies that haven’t arrived yet look like a decline.

What works: reply and interview rates with their counts, a small-sample row muted, and recent weeks drawn dashed because replies may still be coming (fictional data)

Results so far

This is module one and one user, so it shows whether it works, not market adoption. Testing also found a rejection that went undetected because my search assumed the shape of a job-board message. Each row is marked measured or a target.

Privacy
Zero email text sent to an AI service. Holds by design; the open code lets you check it.
Review load
About 1% of ~390 emails needed a decision. Measured, on my inbox.
Blind spot
Nearly one in four applications are ones a job-board tracker can’t see. Measured, on my inbox.
Accuracy
At least 90% correct on company and stage over labelled samples. A target; a tool to measure it per field is planned.
Speed
About one second per email on a mid-range graphics card.
Summary wording
Not measured. Numbers are checked, wording is not, and misread wording appeared in test runs. I’d track how often readers regenerate it.
Setup
Time from download to a first synced dashboard. Not measured yet, and my weakest point.

Next, and what I’d change

Next is the writing module. The full requirements, including the product, Analytics and Writing Studio PRDs, are in the docs. The design rule carries over: make invention visible instead of hoping the model doesn’t invent. Every claim about you is tied to a source, anything without one is flagged “claims to check”, each draft must use something specific to the company and to you, and nothing is learned about you without a one-click approval.

I’d put it in front of five job-seekers and measure edit distance from draft to final, the share of drafts used, claims flagged per draft, and time to a usable first draft. For trust, I’d track how often people override a stage by hand per 100 applications, and whether they keep their own spreadsheet alongside it.

Explore