Inspiration
In 1984, the telescreen watched you and you couldn’t tell when. Today the telescreen is a line in a codebase: analytics.identify(user.email). Most apps send their users’ data to a dozen companies: analytics, session recording, CRMs, AI providers. Nobody tells the user, and often the engineers don’t know either.
Privacy policies say “we may share data with trusted partners.” Code is more honest: if it sends the data, the line exists. So we asked: what if you could ignore what a company says and read what its code does?
In Orwell’s world, informants reported on their neighbours. We built an informant that reports on the code instead. We called it Narc.
What it does
Narc takes any public GitHub repo and answers one question: who’s watching your users?
Who gets the data: it finds every company the app sends user data to (for example Segment, HubSpot, Stripe, Anthropic) and what leaves: email, name, phone, location. Every finding links to the exact line on GitHub, so it is proof, not a guess. What those companies do with it: for each company, live research with Tavily and Exa checks whether it sells data, uses it for ads, or trains AI on it, and how long it keeps it. Every answer comes with a citation. A privacy grade from A to F: for example, dubinc/dub gets a D (55/100), with user data going to 7 companies. The marketing CRM it sends data to says it uses data for ads and AI training. umami gets an A (100/100): no outside company receives anything. Privacy debt: like tech debt, but for user data. Each part of the app’s architecture gets a score from 0 to 100. In dub, the frontend scores 70 (critical) and the API 22. On the interactive architecture map, the leaking layers glow and you can see user data moving along the dependency lines. Catches it before merge: it scans open pull requests and flags any that would add a new data recipient before it ships. Hall of Shame: real scans of popular open-source apps, graded and ranked. Local AI mode: a privacy tool shouldn’t leak your code. Switch on Local AI and every AI call runs on your own machine through Ollama. A built-in network log proves it: on a full analysis it recorded 0 calls to OpenAI. The only outside calls were GitHub, to fetch the code, and Tavily and Exa, to research the companies.
There’s also a full security view underneath: CVEs from OSV.dev, attack surface, findings mapped to MITRE ATT&CK, and an AI threat model.
How we built it Backend: Node.js with zero npm dependencies. It downloads a GitHub repo as a tarball and parses it with our own tar reader. It resolves imports across many languages and sorts every file into architecture layers (UI, API, services, data, integrations, …). Results stream to the browser with Server-Sent Events, so the architecture appears in seconds while the AI agents keep working. Privacy engine: a catalog of about 47 data recipients (analytics, ads, session replay, CRM, AI, payments, email). It detects SDK imports, tracking calls, and personal data (PII) passed into them. It also flags personal data sent to logs and sensitive database columns stored unencrypted. Findings are mapped onto the architecture as privacy debt per layer. AI agents: a Layer Architect, a PR Reviewer, a Backlog Analyst and a Threat Modeler. They use OpenAI’s JSON mode, or Ollama (Qwen 2.5 7B) in Local AI mode, with caching and live status for each agent. Research: Tavily and Exa look up each company’s privacy policy and return a cited dossier. OSV.dev provides vulnerability data. Frontend: plain JavaScript and d3, with a custom layered architecture graph, an animated “Telescreen” showing data flowing to companies, and light and dark themes. Challenges we ran into False alarms kill trust. Early versions flagged comments, test fixtures, Storybook stories, CLI output and SDK version bumps. We added rules that skip code that never ships and only flag real database columns. A narc that cries wolf is worse than none. The irony problem. Our privacy tool was sending your code to OpenAI. We built Local AI mode and a network log of every outside call, so you can verify that nothing leaked instead of trusting us. Running a 7B model on a 16 GB laptop. Ollama handles one request at a time. When we sent 8 at once, the waiting requests hit Node’s 5-minute timeout and failed. The default 4K context window also cut prompts short. We added a one-request-at-a-time queue with retries and built a model with a 16K context. Research that answers the question. Web search on “does X sell data” returns a lot of noise. We filter results to the company’s own policy pages and require a citation for every Yes or No. Showing the whole architecture without clutter. A big repo has thousands of files. We group them into layers so judges and engineers see the full system at a glance, and can click down to the exact line. Accomplishments that we’re proud of Every claim links to proof: an exact line of code, or a cited policy page. Real findings on real, popular apps: papermark F (21), dub D (55), formbricks and documenso C (70), excalidraw A (98), umami A (100). A privacy tool that respects privacy: full analysis on Local AI with 0 OpenAI calls, and the network log to prove it. Privacy debt as a new idea: debt per architecture layer, forecast from open PRs, so teams can pay it down like tech debt. Zero-dependency backend, and results on screen in seconds. What we learned What a company says about privacy and what its code does are often different, and the code is easier to check than the lawyers. The biggest privacy leaks aren’t hacks. They’re ordinary identify() calls that someone added for a dashboard. Precision matters more than recall: one false alarm costs more trust than one missed finding. Small local models can do real analysis if you respect their limits: one request at a time, enough context, and tight JSON prompts. What’s next for Narc A GitHub App that comments on every PR that adds a new data recipient: “This PR starts sending email to Mixpanel.” Policy vs. code check: compare the app’s own privacy policy with what the code actually sends, and flag the contradictions. Mobile apps: iOS and Android SDK detection. GDPR and CCPA reports generated from the data map, for compliance teams. A public, regularly updated Hall of Shame for the most popular open-source apps.