GitHits is the code context layer for AI coding agents. It provides version-aware context from open-source code, documentation, and package data, so agents write more accurate code that developers can trust.
Real casesReal agent replays
Fix this TypeScript React fixture so `npm test` and `npm run typecheck` succeed, preserving queued checkout writes across app reloads.
Without GitHits
With GitHits
Get Started
or just run:
npx githits@latest init GitHits index
GitHits gives coding agents a context layer for indexed code, package docs, package metadata, vulnerabilities, changelogs, dependency graphs, upgrade evidence, and real implementation examples.
The Problem
Coding agents can inspect your repository. When the answer lives in dependency source, documentation, or version history, they may have to search or guess.
Your agent can inspect the files in your repository.
But much of the application’s behavior comes from public frameworks, SDKs, libraries, and transitive dependencies. When the answer lives inside one of those packages, searching the local repository often stops at the import or API call.
The agent can see how your application uses the package. It cannot necessarily see what the package does.
Search results and documentation often describe the latest release. Your project may use an older one.
Between versions, method names change. Configuration options move. Defaults, callback arguments, and lifecycle behavior can change too.
Without the source and documentation for the version in use, an agent may combine information from several releases into an answer that was never correct for any one of them.
A generated change may look natural while relying on an incorrect assumption about a dependency.
It might use an option that no longer exists, miss a required initialization step, misunderstand when a hook runs, or depend on behavior that changed between releases.
The mistake may be obvious immediately. It may also appear later, when a particular request, state transition, or edge case reaches that code.
When the agent cannot verify how a dependency works, it has to find another route.
It may search the web, inspect an installed package, clone another repository, try several changes, or ask the developer for help. Any of these can work, but the same investigation must be repeated for each package and version.
Guess > run > error > retry > burn
The Solution
GitHits is the code context layer for AI coding agents, with versioned source, documentation, package data, changes, and examples from public open source.
GitHits is the code context layer for AI coding agents. It gives agents access to public open-source code, documentation, and package data outside their local repository.
A GitHits query identifies a package, repository, version, or ref. For a fixed version, GitHits maps it to a source commit and retrieves the code and documentation attached to that version.
When an agent reaches an unfamiliar API or dependency behavior, it can query GitHits from the coding tool it already uses. It can search for a symbol, read an exact file, inspect release changes, or find prior art in other public projects.
The results include the package version, repository, and source location. The agent can check what the dependency does instead of relying on a remembered API or documentation for another release.
GitHits complements the agent’s access to your local repository. It provides public open-source context without requiring access to your private source.
The code context layer for AI coding agents
Search, grep, list files, and read exact line ranges across packages and repos.
Read hosted and repository documentation for a specific version.
Dependencies, versions, vulnerabilities, changelogs, and upgrade changes.
Relationships and transitive dependencies across packages and versions.
Prior art and implementation patterns from public repositories, issues, discussions, and pull requests.
Files, symbols, AST, imports, exports
Version history and changes
Markdown, MDX, HTML
Dependencies, imports, call relationships
Vulnerabilities, CVEs, advisories
Changelogs, release notes, diffs
Query GitHits > inspect the evidence > make the change
Why GitHits
GitHits gives coding agents tools to inspect dependency source, documentation, package data, security, changes, dependency graphs, and prior art.
Coding agents can inspect the code in your repository. But application behavior also comes from open-source frameworks, SDKs, libraries, and packages outside that repository.
GitHits is the code context layer for AI coding agents. It gives them tools to navigate dependency source, read documentation, inspect package metadata and dependency graphs, check vulnerabilities, review changelogs, compare upgrades, and find prior art.
The tools answer different questions. When the agent needs to understand an API, it can search for a symbol or read the source. When it is evaluating a package, it can inspect its dependencies, license, and known vulnerabilities. When it is planning an upgrade, it can review what changed between releases. When it needs an implementation pattern, it can look at how open-source projects solved similar problems.
GitHits also keeps the version straight. When the agent specifies a package version or repository ref, GitHits searches the code and documentation for that target.
The agent keeps working in the same coding tool and keeps its view of your local repository. GitHits adds visibility into the open-source dependencies behind it. Together, they let the agent inspect the code it is changing and the code that change relies on.
Without GitHits
The agent can inspect your application code. Dependency source, documentation, package data, vulnerabilities, and release history remain outside its view, so it has to search elsewhere or guess.
30% local repository visible
With GitHits
GitHits adds tools for dependency source, documentation, package data, vulnerabilities, changes, dependency graphs, upgrades, and prior art.
100% local repository + open-source dependencies visible
The Builders
How a GitHub search for an undocumented Azure SDK API became the code context layer for AI coding agents.
GitHits started with a question in Slack.
When documentation didn’t explain something clearly, I had a simple fallback: search GitHub.
If a problem has been solved before, there is usually code somewhere showing how it works. Finding the right example still requires digging through files, issues, and discussions.
One day, Softlandia co-founder Mikko asked in Slack:
Who can find the definition for TranscribeDefinition?
He was building a transcription pipeline using Azure’s Speech SDK and couldn’t figure out how to initialize the object.
The official documentation didn’t show it yet, but the definition was already present in Microsoft’s GitHub repository inside documentation files prepared for a future release.
After finding it, I wrote in Slack:
GitHub search solves a surprising number of problems if the project is open source.
Then I added:
You could probably build a coding assistant that answers questions by searching GitHub with some heuristics.
That message started a discussion inside Softlandia Venture Studio. We decided to explore the idea, and Jaakko bought githits.com for $9.
Much of the practical knowledge about how libraries are used already exists in open-source repositories.
Developers have already recorded how libraries work in source code, documentation, issues, releases, and package metadata. The difficult part is finding the material for the package version or repository ref the agent is using.
Documentation can be incomplete, and raw search is noisy. Without the relevant source and package data, an agent may produce a plausible answer based on the wrong API or release.
Developers resolve these questions by inspecting source, reading documentation, checking package data, reviewing changes, and looking at how other projects solved similar problems. Doing that by hand works. Repeating it across dependencies, versions, and tasks is the problem GitHits was built to solve.
GitHits is the code context layer for AI coding agents. It indexes open-source code, documentation, and package data by version, then exposes tools for code navigation, package inspection, vulnerability checks, changelog and upgrade review, and prior art.
Agents query these tools from the coding environments they already use, so they can inspect dependency evidence without cloning repositories or browsing from scratch.
Engineers using tools such as Claude Code, Cursor, or Copilot when an unfamiliar dependency or undocumented API blocks the task.
Helping Claude Code find undocumented C++ APIs directly from the code.
— Onni Hakala, GitHits user
Engineers using packages whose documentation, examples, or APIs change faster than a model’s built-in knowledge.
I swapped my ritual of 20 browser tabs and stale Stack Overflow answers for a tool that actually understands what I’m trying to do.
— Atharv Singh, GitHits user
Co-founder, CTO
I created the opencv-python package. It has over 1B downloads. I wanted to keep contributing to the open source ecosystem. Now I'm building GitHits search agents and the reasoning layer.
Co-founder, Chief Architect
I thought I was done with startups, but I realized the AI coding revolution is just too big an opportunity to miss. I'm responsible for building the code indexing and intelligence engine that understands dependencies.
Co-founder, CPO
I was one of the first people to test Olli-Pekka's first prototype. I tried something hard: writing a CUDA kernel. Every other AI tool produced code that wouldn't compile. GitHits passed my tests on the first try. I wanted to join the team.
Co-founder, CEO
After my first startup, I was on the hunt to find an idea I'd be excited about. When Olli-Pekka pitched “a coding problem solver using GitHub search with smart heuristics”, I was immediately hooked.
Founding Designer
20+ years shipping digital products across retail, fintech, and entertainment, used by millions. Joined GitHits after experiencing the frustration of AI giving answers that look right but don't actually work. Now I'm fixing that through design.
GTM Engineer
Built AI/LLM automation across multiple production systems — OpenAI, Gemini, Vertex. Awarded for rapid technical growth, strong ownership of complex systems, and continuous skills improvement at Mavric. Now building the GitHits GTM engine.
FAQ
How GitHits works, what it covers, how to get started, and how it handles private code, retrieved context, and open-source licenses.
GitHits is the code context layer for AI coding agents. It gives agents tools to search open-source code and documentation, read exact source files, inspect packages, check vulnerabilities, review changes, compare upgrades, and find prior art.
GitHits can search and navigate open-source repositories whether or not they are published as packages. Package-specific tools, such as dependency, vulnerability, license, changelog, and upgrade inspection, are available for supported package ecosystems.
To get started, run npx -y githits@latest init. GitHits detects your coding tool, signs you in, and configures the MCP server automatically.
GitHits is useful when a task calls for context from open-source code, documentation, or package data. Common cases include researching an integration, understanding how a library works, investigating version-specific behavior, checking a package, or finding prior art.
During setup, the GitHits CLI wizard can install guidance that tells your agent when and how to use GitHits. You can also ask the agent to use GitHits explicitly.
GitHits indexes open-source repositories, documentation, and package data by package version or repository ref. When an agent asks for a specific target, GitHits resolves it to the corresponding commit and makes that source queryable.
The index records files, symbols, imports, call relationships, and documentation, so the agent can search and read the exact code it needs.
Fixed package versions and commits remain tied to the same underlying source. GitHits may re-index them as its parsing and search improve, but the source itself does not change.
Moving refs, such as branches and HEAD, follow the repository and update as it changes.
GitHits uses GitHub authentication to identify your account. Signing in does not give GitHits access to your private repositories.
No. GitHits does not access, index, search, or store your private repository code.
Your coding agent works with the code in your local repository. GitHits provides context from open-source code, documentation, and package data.
No. GitHits does not use your code, prompts, outputs, or personal data to train AI models. Service data is processed only to provide GitHits and remains governed by our Privacy Policy and Data Processing Agreement.
GitHits retrieves indexed open-source code, documentation, package data, changelogs, vulnerability data, and examples. It does not modify your code.
Its search infrastructure and MCP tools include guardrails intended to reduce prompt injection and other malicious-content risks. No external source should be treated as automatically safe, and developers should review generated code before shipping it.
For code, documentation, and package queries, the agent specifies a package, version, repository, or ref. GitHits resolves that target to indexed source and package data.
For prior art, GitHits ranks open-source examples using relevance and repository signals such as activity, adoption, maintenance, and license status. License filters are applied before examples are selected, and results link back to their sources.
Prior-art searches use strict license filtering by default. This excludes repositories with copyleft licenses and repositories that do not declare a license. You can relax these restrictions or disable license filtering.
Package inspection also reports license information, so agents can check a dependency's license before recommending or using it.
The Blog
Product updates, engineering notes, and case studies from GitHits.
July 21, 2026
We used GitHits to explore the Postgres 19 release and surface what changed. Six features came back. A coding agent without GitHits could not reach any of them.
July 20, 2026
How Agent Runner went from a 23-minute prototype to a finished game built with coding agents, source context, generated concepts, and hand-made art.
July 16, 2026
What a user's full GitHits MCP trace revealed about slow indexing, excessive tool calls, JSON overhead, missing visibility, and what we're changing.
July 7, 2026
A source-backed comparison of Apple container and Docker Desktop on macOS, using GitHits to trace every architecture claim to docs and code.