Skip to main content
GitHits is most useful when your agent needs context that is outside your local repo. Use it when the answer depends on how open-source code actually works, not just on the files already in the workspace. GitHits gives AI coding agents version-aware access to indexed public open-source code, package docs, package metadata, vulnerabilities, changelogs, dependency graphs, upgrade evidence, and real implementation examples.

​
Planning and research

Use GitHits before implementation when the agent needs to choose an approach, evaluate an unfamiliar API, or understand how a library is used in real projects.

​
Research a dependency before changing code

Ask the agent to use Code Navigation when the work depends on a library already in your stack. 
Use GitHits Code Navigation to inspect <package_name> version that we have in use. Find the relevant API and source behavior before proposing an implementation plan. Use Documentation Access if you also need the package docs.
Use this for:
  • Version-specific behavior
  • Undocumented APIs
  • Dependency internals
  • Stack traces that point into third-party code

​
Read package documentation

Ask the agent to use Documentation Access when package docs explain public behavior better than source. 
Use GitHits Documentation Access for <package_name>. Find the docs page about <topic>, read the relevant section, and compare it with source if the behavior still matters.
Use this for:
  • Public API behavior
  • Configuration options
  • Migration notes
  • Docs-source disagreements

​
Review dependency risk

Ask the agent to use Package Inspection before adding or upgrading dependencies. 
Use GitHits Package Inspection for <package_name>. Check package metadata, vulnerabilities, dependencies, and changelog context before recommending whether we should use it.
Use this for:
  • Dependency selection
  • Upgrade planning
  • Vulnerability triage
  • Changelog review

​
Find prior art and implementation patterns

Ask the agent to use Code Examples when you need prior art or current implementation patterns and do not need a version-specific source inspection. 
Use GitHits Code Examples to research prior art and how real projects implement <task or API>. Compare the common approaches, then propose a plan for our codebase.
Use this for:
  • Niche integrations
  • Unfamiliar SDKs
  • Framework-specific patterns
  • Current ecosystem conventions

​
Implementation and debugging

Use GitHits during implementation when the agent starts guessing, makes repeated small changes, or cannot explain why a dependency behaves the way it does.

​
Help the agent out of a loop

If the agent retries similar fixes without progress, stop the loop and point it at indexed source, docs, and package context. 
Stop guessing. Use GitHits Code Navigation to inspect <package_name> version that we have in use. Search for <symbol, behavior, or error message>, read the relevant source lines, then explain the fix before editing code.
Use this when:
  • The same test keeps failing
  • The agent keeps changing nearby code without evidence
  • An error message comes from a dependency
  • Docs and implementation behavior disagree

​
Verify an implementation detail

Before committing to an API usage, ask the agent to verify the exact behavior. 
Use GitHits Code Navigation to verify how <package_name> handles <behavior>. Read the implementation before finalizing this change. Use Documentation Access if documented behavior matters too.
Use this for:
  • Method options and defaults
  • Error handling behavior
  • Middleware order
  • Serialization or parsing behavior

​
Borrow prior art, not a guess

When the agent needs prior art or an example but not a version-specific inspection, use Code Examples. 
Use GitHits Code Examples to find prior art for <task>. Adapt the pattern to our codebase instead of inventing one from memory.
Use this for:
  • New feature patterns
  • Library integration examples
  • Idiomatic setup code
  • Test patterns

​
Keep prompts concrete

GitHits works best when you give the agent the package, API, symbol, behavior, or error message that matters. You do not need to provide the exact dependency version if it is already in your repo. The agent can usually infer it from lockfiles, manifests, or imports. For shorter copy-paste prompts, see Trigger GitHits manually.