Unlisted

Inspiration Engineering hiring still starts from résumés and job boards, but the best evidence of what an engineer can do is already public in the code they ship. Recruiters rarely read it, and the roles that fit a strong engineer best are often ones a company hasn't posted yet. We also didn't trust a single AI model to make hiring claims about a real person. A model asked to make the case will make it whether or not the code supports it. So we set out to build something that reads the code, argues for a specific role, and then has a second, independent model check the argument before anyone hits send.

What it does Enter a GitHub username and pick a target company. Unlisted runs a five-stage pipeline and streams each stage to the screen as it finishes:

Extract: pulls the person's 10 most recent non-fork repositories and their READMEs, and derives what each one proves. Synthesize: turns those repos into structured skills and evidence, with every item tied to a specific repository. Role thesis: cross-references that evidence against the company's real engineering signals (blog excerpts and job requirements) to propose a specific role, even one they haven't listed. Every claim must cite either a repo or a company signal. Independent audit: Google Gemini scores the thesis in a separate, isolated call. It sees only the claims, the repo evidence and the company signals, never the reasoning that produced the thesis, so it can't simply agree with it. It returns SUPPORTED, PARTIALLY SUPPORTED or OVERREACHING, plus a verdict for each claim. Pitch: drafts cold outreach using only the claims Gemini marked SUPPORTED, ready to copy with a subject line. If the audit calls the thesis overreaching, Unlisted rewrites it more conservatively and sends it back for a second audit. If still nothing holds up, it says so and doesn't write a pitch.

How we built it Backend: Python + FastAPI. POST /api/analyze streams each stage as a server-sent event, so the UI fills in progressively instead of sitting behind a spinner for a minute. Models: OpenAI (with Groq as a fallback) in structured JSON mode, validated with Pydantic schemas, handles synthesis, the thesis and the pitch. Google Gemini is the independent auditor, with strict prompt isolation. Evidence tracing: every thesis claim is matched back to a real extracted repository or a company signal, and claims that can't be traced trigger a regeneration. Company signals: kept in a JSON file that's reloaded on every request, so we can edit a company's signals between runs without restarting the server. Frontend: a React + TypeScript + Vite + Tailwind interface with framer-motion animations. It reads the SSE stream with fetch, because the browser's EventSource can't send a POST. Demo Safety Mode: replays a real recorded run stage by stage, so a live demo still works if the venue Wi-Fi or an API rate limit doesn't. Testing and deployment: a pytest suite with mocked API calls, a backtest harness that runs real teammates' GitHub accounts against every company, and a single Docker container deployed to Google Cloud Run. Challenges we ran into Stopping the model from flattering the candidate. Early theses read well but claimed more than the code showed. We added per-claim citations, independent auditing with no access to the original reasoning, a conservative rewrite with a second audit, and a rule that only fully supported claims reach the pitch. Model availability broke our backtest. Our first backtest ran 5 real GitHub accounts against 5 companies (25 runs). Only 3 finished, and 20 failed at the synthesis stage because a Gemini model we depended on started returning 404s. That's why we built a shared LLM transport layer with retries, backoff, and fallback across several models and providers. Streaming progress to the browser. We needed to stream results from a POST request, handle a stage failing partway through, and still show which later stages never ran and why. Matching claims to sources. Models cite sources loosely, as in "fastapi (README)". We wrote matching that ties a citation to the right repository without false positives on similarly named repos. Accomplishments that we're proud of Self-checking, end to end. Every claim in the final pitch traces back to a specific repository and has passed a second model's audit. Honest failures. The system can say "no role survived verification" instead of producing a confident pitch anyway. Live streaming. The full five-stage pipeline streams to the UI, and you can watch the audit and any rewrite happen. Demo-proof. Demo Safety Mode gives judges a real recorded run whatever the network conditions. Tested on real people. We ran it against our own teammates' GitHub accounts, not just famous open-source maintainers. What we learned One model checking another only works if they're properly isolated. Once the auditor could see the first model's reasoning, it tended to agree with it. Structured output (JSON schemas plus validation plus retry) matters more than prompt wording when you chain several model calls. For any demo that depends on external APIs, plan for failure: fallbacks, clear error states, and a replay mode are what make it survive a live stage. A real backtest is humbling. It showed us reliability problems a handful of manual runs never did. What's next for Unlisted Deeper code evidence: go beyond READMEs to commit history, pull requests, code review activity and contributions to other people's projects. Live company signals: pull engineering blogs, changelogs and job postings automatically instead of keeping a hand-curated list. Batch sourcing: rank many candidates against one company's needs, not just one pair at a time. Recruiter workflow: save runs, track outreach, and export to an applicant-tracking system. Candidate opt-in: let engineers see and correct what their code says about them before a recruiter does. Better evaluation: a larger, labeled backtest that measures how often audit verdicts agree with human reviewers.