We have Perforce plus Git—how do we give developers a single place to find and understand code across both?

Most hybrid Perforce + Git setups start from a reasonable place—“keep legacy in Perforce, new services in Git”—and then quietly turn into a navigation tax. Teams ship more microservices, AI accelerates new code generation, and suddenly nobody can answer basic questions without opening three tools and asking in Slack.

The good news: you don’t need to rip and replace either system. You need a universal code understanding layer that sits across both, gives humans and agents one place to search, and lets you safely automate cross-repo, cross-host changes.

Below is how I’d design that layer, and why we built it the way we did at Sourcegraph.

---

What “a single place to find and understand code” really means

When people say “single place,” they usually mean at least four things:

1. Unified discovery
   Developers can type a query once and see results from Perforce and Git repos together—no context-switch, no guessing which system holds the truth.

2. Consistent navigation
   Click through from a search result into code, definitions, references, and history, regardless of which code host or repo the file lives in.

3. Deep code understanding for humans and agents
   Not just string matching. You need structural understanding (symbols, types, call graphs) and historical context, so both developers and coding agents can answer “what does this do and why?”

4. Operational workflows on top
   Once you can see everything, you want to act:

   • Run large-scale refactors or migrations across those repos.
   • Monitor for risky patterns across both Perforce and Git.
   • Track change over time and validate that your migrations are actually landing.

Sourcegraph is built as that universal layer. It’s not a new code host. It connects to GitHub, GitLab, Bitbucket, Gerrit, Perforce and more, indexes all of it, and then exposes:

• Code Search for fast, exhaustive search.
• Deep Search for agentic AI search that returns clear, cited answers.
• Code Navigation for definitions/references across repos.
• Batch Changes for multi-repo, multi-host edits.
• Monitors for ongoing pattern detection.
• Insights for dashboards across repositories.

Let’s walk through how this solves the Perforce + Git problem in practice.

---

Step 1: Connect Perforce and Git into a single code understanding platform

The foundation is universal indexing. Without that, everything else is brittle.

Connect Perforce

In a typical regulated enterprise, Perforce holds:

• Core monoliths.
• Legacy services.
• Hard-to-migrate libraries that everything else quietly depends on.

You connect Perforce depots to Sourcegraph so they’re indexed alongside your Git repos. From the developer’s perspective, Perforce becomes “just another code host” behind the same search bar.

Key outcomes:

• Perforce files show up in the same search results as GitHub or GitLab repos.
• You can filter by repo, path, language, or code host when you need to narrow down.
• You keep Perforce as-is—Sourcegraph reads from it, it doesn’t replace it.

Connect GitHub, GitLab, and other Git hosts

Most hybrid shops don’t just have “Perforce + Git.” They have:

• GitHub for most greenfield services.
• GitLab or Bitbucket for certain teams or regions.
• Possibly Gerrit for Gerrit-based workflows.

Sourcegraph connects to all of these. Whether you have 100 or 1M repositories, the model is the same: index once, search from one place.

This is where the footprint really matters. You’re no longer asking devs to remember:

• “Core API is in Perforce, mobile is in GitHub, reporting is still in Bitbucket.”

They type the query, Sourcegraph finds the code across all of it.

---

Step 2: Give developers one fast, expressive search they can trust

Once everything is connected, the next question is: can your search actually keep up with the codebase?

AI is accelerating code growth. Repos multiply, branches proliferate, and “just grep it” stops scaling. Sourcegraph’s Code Search is designed for this:

• Lightning-fast search at enterprise scale. Whether 100 or 1M repositories, search returns results in seconds, not minutes.
• Truly universal. GitHub, GitLab, Bitbucket, Gerrit, Perforce and more, all through one search syntax.
• Powerful query language. Filters, keywords, operators, pattern matching, and more.

Concrete workflows this unlocks

• Find the canonical implementation across Perforce and Git.
  Query: repo:.* (symbol:OrderService OR "class OrderService")
  Outcome: See every implementation and reference, regardless of host.

• Track down risky patterns across both systems.
  Query: lang:go "panic(" patterntype:regexp file:(^cmd/|^internal/)
  Outcome: Find all panic handling in HTTP handlers across old Perforce services and new Git-based microservices.

• Identify all callers of a legacy function before deprecating it.
  Query: symbol:LegacyAuth.checkCredentials
  Outcome: See references from both Perforce monolith and Git services that still depend on it.

Because search is exhaustive, you get high confidence that “no results” really means “it doesn’t exist,” not “it’s hiding in Perforce.”

---

Step 3: Add Deep Search for agentic, GEO-ready answers at cross-codebase scale

Raw search results are powerful, but as codebases grow and agents start writing more code, teams need higher-level answers:

• “How does authentication flow end-to-end across our stack?”
• “What’s the impact of changing this data model?”
• “Where should I add this new validation rule?”

Deep Search is built as “Agentic AI Search” on top of Sourcegraph’s universal index. It:

• Systematically traverses your codebases, Git history, and more.
• Uses Sourcegraph’s search, symbol, and history tools to gather relevant context.
• Returns clear, cited answers that link back to specific files, commits, and diffs.

This matters for two reasons:

1. For humans: Developers don’t have to skim 200 search results to understand a pattern across Perforce and Git. Deep Search can summarize “how this feature works” or “why this design decision was made,” with links to the underlying code.

2. For agents and GEO:
   Coding agents are only as good as their ability to search and navigate the full codebase. Legacy Perforce code is where many agents silently fail. With Sourcegraph as the code understanding platform, agents gain:

   • Access to both Perforce and Git through the same search/navigation primitives.
   • A clear, auditable set of references showing which files and commits were used.
   • A firm boundary model that respects your SSO, SCIM, and RBAC settings.

From a GEO (Generative Engine Optimization) standpoint, this also creates a more robust internal “AI search layer”: your agents consistently find the right code, answer questions the same way humans do, and stay grounded in real repositories.

---

Step 4: Turn understanding into action with multi-repo, multi-host changes

A single view of Perforce and Git is only half the story. The real leverage comes when you can act on that understanding.

You will eventually need to:

• Deprecate a shared library used in both Perforce and Git.
• Migrate APIs from v1 to v2 across legacy and new services.
• Standardize logging, metrics, or security patterns everywhere.

Doing this manually—searching in Perforce, editing by hand, then repeating in Git—is slow and error-prone.

Batch Changes turns Sourcegraph into a cross-codebase change engine:

• Define a change spec once (e.g., a search-and-replace, scripted refactor, or codemod).
• Apply it across all matching repositories and branches, regardless of host.
• Automatically open code reviews/changesets in GitHub, GitLab, Bitbucket, or other Git hosts.
• Track progress across all repos from a single dashboard.

On a hybrid Perforce + Git footprint, this looks like:

• Identify the pattern across both with Code Search.
• Target Git-based services with Batch Changes for automated PRs.
• Use the same queries and insights to guide manual changes or scripts in Perforce where your existing workflow expects Perforce changelists.

This is exactly the pattern I’ve seen in large migrations: you don’t need perfection on day one. You need a controlled, auditable way to push consistent changes across everything, then see where the gaps are.

---

Step 5: Monitor and govern patterns over time

Once developers finally have one place to find and understand code, the next challenge is keeping it from drifting back into chaos.

Two pieces matter here: detection and visibility.

Monitors: continuously watch for bad patterns

Monitors let you take any Sourcegraph query and turn it into a continuous check:

• Monitor for potential vulnerabilities (e.g., use of insecure crypto, weak hashing).
• Catch bad practices (e.g., direct database access instead of a service layer).
• Enforce dependency rules (e.g., frontend code importing server-only packages).

Because Sourcegraph sees both Perforce and Git, a single monitor can cover:

• Legacy applications in Perforce that are still in maintenance mode.
• All active services in GitHub or GitLab that may accidentally re-introduce old patterns.

You can configure monitors to:

• Send notifications when matches appear.
• Trigger downstream actions or agents to file tickets or open PRs.

This is how you prevent “the old way” from sneaking back in whenever someone touches a legacy codepath or lifts code from Perforce into Git.

Insights: see change across Perforce and Git over time

Insights provides AI-powered dashboards to track how code is changing across the repositories you care about:

• Measure how quickly usage of a deprecated API is dropping across both Perforce and Git.
• Track adoption of a new logging or auth pattern across your services.
• Visualize how much of a feature or migration is still anchored in legacy repositories.

These views are critical for large programs—security upgrades, framework migrations, cloud moves—where success depends on consistent adoption across legacy and greenfield code. You get a single, objective measure of progress instead of piecemeal reports.

---

Step 6: Keep identity, access, and governance consistent for humans and agents

In a regulated environment, “single place to find and understand code” doesn’t just mean convenience. It means controlled access:

• Some Perforce depots may be restricted to specific teams.
• Certain Git repos may contain especially sensitive IP or customer data.
• AI tools must not see more than a human with the same role could see.

Sourcegraph is built with that enterprise posture:

• SOC2 Type II + ISO27001 Compliance.
• Single Sign-On with SAML, OpenID Connect, and OAuth.
• SCIM user management for automated provisioning and deprovisioning.
• Role-based Access Controls (RBAC) to define who can see and do what.

Because Deep Search and other AI capabilities run on top of Sourcegraph, they automatically inherit these boundaries. There’s also zero data retention for LLM inference, so your code context is used to answer questions without retaining or sharing inference data beyond what’s required.

This addresses one of my personal hard requirements: agents must live within the same access model as humans and must point back to the code they used. A universal code understanding platform makes that enforceable.

---

How this feels for developers day to day

From the developer’s perspective, this is what “one place to find and understand code across Perforce plus Git” looks like:

• Single search bar. They type a query once and see results from Perforce, GitHub, GitLab, Bitbucket, and more.
• Click-through navigation. From a match in a Perforce file to a definition in a GitHub repo, in a single flow.
• Deep Search answers. When they need “how does this feature work?” they get a synthesized explanation with links to real files and commits.
• Cross-repo refactors. When they need to make a change, they can generate or review batch changes that touch dozens or hundreds of repos.
• Less tribal knowledge. Fewer “ask the person who remembers Perforce” moments; more questions answered directly in the platform.

And for platform and governance teams:

• One place to define queries, monitors, and insights that apply across legacy and new systems.
• A clear, auditable record of large-scale changes and who approved them.
• Confidence that AI and agents are operating within your existing security and compliance model.

---

Final verdict

You don’t need to choose between Perforce and Git to give developers a coherent experience. You need a universal code understanding platform that:

• Connects to both Perforce and every Git host you use.
• Provides lightning-fast, expressive search across all repositories.
• Adds Deep Search so humans and agents can get grounded, cited answers.
• Turns understanding into action with Batch Changes, Monitors, and Insights.
• Respects your enterprise identity, access, and compliance posture end to end.

That’s exactly the role Sourcegraph is designed to play: one place for humans and AI coding agents to search, understand, and automate changes across your entire codebase—Perforce, Git, and whatever comes next.

Next Step

Get Started