How GITTO works

GITTO is a workspace for understanding unfamiliar code.

Not a chatbot you converse with. Not a documentation generator that produces stale summaries. A workspace where you build a real mental model of a codebase — the structure, the relationships, the history — and ask grounded questions whose answers you can actually verify.

The founding principle: you need a trustworthy map before you need explanations. GITTO computes the structure of your repo as facts — modules, entry points, dependencies, relationships — then uses AI to help you navigate them. Every answer shows you the code it came from. You can always check.

When you submit a repo — paste a GitHub or GitLab URL, or give it a local path — GITTO reads it end to end.

Nothing is invented. Every module, relationship, and entry point GITTO shows you is present in the actual files. The deterministic model is built first; AI explains over it. Structure you can trust, answers you can inspect.

Every answer GITTO gives comes with the evidence it was derived from: the file paths, line ranges, and the exact code that informed the response. Not paraphrased. Not reconstructed. The actual source.

This is not optional UX. It is the product's core promise.

A helpful-sounding answer you cannot verify is worse than no answer at all — it builds false confidence. GITTO's rule: if there is nothing relevant to retrieve, there is no AI call. You get a clear "I couldn't find relevant evidence" rather than a plausible guess. The confidence level on every answer tells you how strong the signal was.

You can always inspect the evidence. If an answer doesn't make sense, the evidence will show you why.

By default, GITTO processes everything on your own server. Your code does not leave the box.

When you choose to use a hosted AI provider — for faster responses, or if you don't have a local model — GITTO logs a clear data-boundary notice at startup.

Connect a repository to see active providers.

The configuration above reflects what is running right now, pulled live from the server. Change it by setting environment variables — the status updates on reload.

Explore a repo

Start with the visual map. See the modules, entry points, dependencies, and file relationships at a glance. Filter by category, language, or kind. Click any node to open the file and browse its contents. The architecture tour walks you through the structure step by step — from entry points to modules to how they connect.

Ask questions

Type a question about any part of the codebase. GITTO searches semantically and by keyword, retrieves the most relevant code, and grounds the answer in what it found. Every answer links to the evidence — file paths and line ranges you can open directly. Your question history for each repo is saved, so you can build on what you learned.

Understand health and history

Pull the full git history to see which files change most often, who contributes to which parts of the codebase, and how activity has trended over time. High-churn files get a risk overlay on the map. Any file can be explained in plain English on demand — what it does, what it contains, and how it fits into the rest of the codebase.

Bring any repo

Paste a public GitHub or GitLab URL and GITTO clones and indexes it automatically. Point to a local path for repos already on your machine. Re-sync when the upstream changes — only what changed gets re-indexed.

Health metrics and contributor map

The full git history panel is landing soon: bus factor, maintenance health, and growth velocity based on real commit data — not estimates. Plus a contributor map showing who owns which part of the codebase, so you know exactly who to ask about what.

Repo intelligence

A deeper layer of structural insight derived from the code itself: which modules are tested and which are dark zones; files that nothing imports (candidates for dead code); the domain vocabulary — the names this codebase uses for its concepts, extracted directly from source identifiers. Deterministic facts, not generated guesses.

Team workspaces

Explore the same repo as a team. Share your exploration paths, annotate findings, and hand off a structured onboarding map to new joiners — without requiring a synchronous walkthrough. The async-first collaboration layer, built on the solo exploration loop.