P.I.P.E.R.
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.
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.
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.
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.
- The first run. Setup is too heavy for anyone but a power user. You create your own Google sign-in credentials, and Google limits unverified apps to 100 test users, so distribution is an open question.
- The evidence. Tested on one person so far. The problem work was informal: my own routine, a few friends and public threads, with no structured interviews.
- Accessibility. I had Claude audit the interface by reading the code and measuring WCAG colour contrast. It found contrast and keyboard gaps that I haven’t fixed yet, and I haven’t tested with a screen reader.