Most product pages focus on features and solutions. We decided to publish the problem statement behind GitHits instead.
The ideas described here are not conclusions. They are hypotheses about how AI-assisted software development is evolving and where current tools fall short. GitHits is our attempt to test those hypotheses in the open.
AI coding agents generate code extremely well for common situations.
But software development contains a long tail of problems that models struggle with:
undocumented APIs
unusual library integrations
subtle version differences
ecosystem-specific conventions
When an AI coding agent encounters an unfamiliar library, API, or integration during development, it often fails predictably.
It retries.
The agent rewrites the code, adjusts parameters, or attempts a different approach. Sometimes it gets closer to a solution, but often it enters a loop of variations that almost work.
At this point, developers usually step in and do what developers have always done: research.
They search GitHub repositories, read issues and discussions, inspect source code, and look for examples of how similar problems have been solved before.
In many cases, the correct implementation already exists somewhere in open source.
The challenge is finding it quickly.
A developer asks an AI coding agent how to implement exponential backoff for S3 batch processing in Go.
The agent generates several variations of retry logic, but none follow the conventions used in the AWS SDK. After several attempts, the developer searches GitHub and finds a production repository that implements the correct pattern.
The answer existed the entire time. The difficulty was locating the relevant implementation.
Situations like this happen constantly in modern development workflows.
The gap exists because AI agents and developers access knowledge in fundamentally different ways.
Large language models generate code from statistical patterns learned during training. They do not retrieve specific implementations from open-source repositories when producing answers.
This makes them highly effective for common programming tasks, but weaker when a problem requires knowledge of how a particular library, framework, or ecosystem behaves in practice.
When a model encounters unfamiliar territory, it fills the gap with plausible guesses.
Sometimes those guesses work. Often they do not.
Across millions of repositories, developers have already solved integration problems, handled edge cases, and established patterns for how systems are built.
Developers routinely learn from these examples by:
reading source code
exploring repository histories
studying issue discussions
examining tests and documentation
This process works well for humans but is difficult for AI agents to perform reliably.
Tools like GitHub search and modern code search engines make it possible to locate code across repositories.
However, they return lists of results rather than clear answers.
Developers must still interpret those results:
determine which repositories are trustworthy
understand how examples relate to their problem
extract the relevant implementation pattern
adapt it to their own codebase
For AI agents operating autonomously, this process is even more difficult. Agents lack the context needed to evaluate which example represents the best pattern to follow.
These issues appear in several common development scenarios.
A developer or AI agent encounters an unfamiliar API, an integration error, or a failing test.
The solution often already exists somewhere in open-source code, but locating the relevant example requires manual research across repositories and documentation.
Reducing the time required to find a working implementation can significantly accelerate development.
Before writing code, developers often explore how similar problems have been solved elsewhere.
They examine repositories, read documentation, and evaluate patterns used by other projects.
AI agents attempting to assist with planning face the same challenge: they lack an efficient way to survey real implementations before committing to an approach.
AI models perform best in languages and frameworks with large training datasets.
In ecosystems with less representation—such as Rust in specialized domains, Elixir, OCaml, Zig, and others—model output quality can drop noticeably.
Developers in these communities frequently rely on studying existing repositories to understand correct patterns.
AI agents currently struggle to do the same.
AI coding agents are becoming a core part of modern software development, and they are already responsible for generating a growing share of the world’s code.
Developers increasingly rely on tools like Claude Code, Cursor, and Copilot to generate code, explore APIs, and accelerate implementation.
But AI-assisted development will only reach its full potential when agents can learn from the same source of truth developers rely on every day: real implementations in open-source code.
Instead of guessing how something should be built, agents should be able to see how similar problems have already been implemented in real software.
Software development already contains a vast body of working implementations inside open-source repositories.
Developers rely on this knowledge constantly. They read code, study patterns, and learn from how other systems were built.
GitHits is a code example engine that distills implementation patterns from open-source repositories so developers and AI coding agents can build on how similar problems have already been solved.
Instead of guessing how something should be implemented, developers and agents should be able to start from patterns that already exist in real code.
Over time, this creates a clearer map of how software is actually built across the open-source ecosystem.