← All articles
Security7 min read

Your Code Never Leaves Your Repository. Here's How.

Published February 12, 2026

When we ask you to connect your GitHub repository, we understand the weight of that request. Your codebase is your most valuable intellectual property. That's why we designed Holmes from the ground up with a single, non-negotiable principle: we never store your source code.

This isn't a marketing statement — it's an architectural decision baked into every layer of our system. In this article, we'll walk you through exactly how Holmes analyzes your codebase, what data we keep, and what we don't.

How Codebase Analysis Works

When you connect a repository, Holmes runs a three-phase analysis pipeline. Each phase is purpose-built to extract only the structural understanding needed to generate intelligent test scenarios — without ever persisting your source code.

1

Phase 1: Structure Mapping

Holmes reads your repository's file tree through the GitHub API — not by cloning your repo. We use GitHub App installation tokens (not your personal access token) to request the directory structure. From this tree, we identify relevant source files and skip everything that doesn't matter: node_modules, dist, build artifacts, and vendor directories.

We then fetch individual files on-demand through the GitHub Contents API. These files live only in memory during analysis and are never written to disk or stored in our database.

Key point: Your repository is never cloned. File contents exist only in memory during processing and are discarded immediately after.

2

Phase 2: AI-Powered Understanding

The relevant code snippets are sent through five focused analysis passes using Anthropic's Claude API. Each pass extracts a specific dimension of understanding: your application's pages and routes, data models, authentication flows, and user journeys.

Critically, every single API call to Claude includes the zero-data-retention header. This means Anthropic contractually guarantees that your code snippets are not stored, logged, or used for model training. The data is processed and immediately discarded on their end.

We also apply smart truncation before sending any code: large files are reduced to their essential parts — imports, route definitions, component structures — while implementation details are stripped. This minimizes exposure while maximizing understanding.

Key point: All AI processing uses zero-data-retention. Anthropic does not store or train on any code sent through Holmes.

3

Phase 3: Blueprint Generation

The final phase merges the AI outputs into a structured Application Blueprint — a JSON document that describes your application's architecture in abstract terms: pages, flows, entities, and their relationships. This blueprint is what Holmes uses to generate and prioritize test scenarios. It contains no source code.

Key point: Only the structural blueprint is stored — a metadata description of your app, not your code.

What We Store vs. What We Don't

We never store

  • ✕Source code files
  • ✕Repository clones or mirrors
  • ✕Environment variables or secrets
  • ✕API keys or credentials from your code
  • ✕Raw file contents in our database

What we keep

  • ✓Application Blueprint (structural metadata)
  • ✓Page routes and navigation structure
  • ✓User flow descriptions (login, checkout, etc.)
  • ✓Entity names and field types
  • ✓Tech stack detection (framework, database)

GitHub App Authentication

Holmes integrates with GitHub as a GitHub App — not through personal access tokens. This is a deliberate security choice:

  • ●Scoped permissions: You grant access only to the repositories you choose. We can't see anything else in your GitHub account.
  • ●Revocable at any time: Uninstall the GitHub App from your organization settings, and all access is immediately terminated.
  • ●Short-lived tokens: Installation tokens expire automatically. We never store long-lived credentials to your repositories.
  • ●Audit trail: Every API call is logged by GitHub and visible in your organization's security audit log.

Why We Need Repository Access

You might wonder: if Holmes is a QA tool that tests your running application, why does it need to see your code at all?

The answer is context. By understanding your application's architecture — its routes, data models, authentication flows, and business logic — Holmes generates test scenarios that are far more intelligent than what a blind crawler could achieve. Instead of randomly clicking through your UI, Holmes knows:

  • ●Which user flows are critical to your business
  • ●What form fields expect which validation rules
  • ●How authentication gates access to different areas
  • ●What edge cases and error states exist in your application

This structural understanding is what makes Holmes effective. And we achieve it without ever keeping your code.

Our Security Commitment

  • ✓Zero code storage: Source code is never persisted to disk, database, or any storage system.
  • ✓Zero-data-retention AI: All LLM processing uses Anthropic's zero-data-retention policy.
  • ✓In-memory processing: File contents exist only in RAM during the analysis window and are garbage collected immediately after.
  • ✓Minimal data principle: We store only the structural blueprint your QA needs, nothing more.
  • ✓EU-hosted infrastructure: Holmes runs on European infrastructure, fully compliant with GDPR.

We built Holmes because we believe QA should be intelligent, thorough, and automated. But we also believe that intelligence shouldn't come at the cost of trust. Your code is yours. We just read it once, understand the structure, and then forget it.

If you have questions about our security practices, we're always happy to talk. Reach out at security@useholmes.com or book a call with our team.