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.

​
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.

​
Find existing implementation patterns

Ask the agent to use Code Examples when you want current, source-linked patterns from GitHub. 
Use GitHits Code Examples to research 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

​
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

​
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

​
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 source-backed 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 a pattern, not a guess

When the agent needs an example but not a version-specific inspection, use Code Examples. 
Use GitHits Code Examples to find a real implementation of <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.