Introducing Systems: Cross-Repo Analysis Just Got a Whole Lot Smarter

If you've ever tried to make sense of a sprawling microservices architecture spread across a dozen repositories, you'll know the pain. You've got duplicated logic hiding in plain sight, API endpoints that mirror each other across services, and code quality issues that no single-repo tool ever surfaces — because no single-repo tool can see the full picture.

That's exactly the problem we built Systems to solve.

What Is a System in DeCoder?

A System is a new high-level construct in DeCoder that lets you group multiple repositories together to represent the real-world software system they collectively form. Rather than analysing each codebase in isolation, DeCoder now treats the whole thing as a single, connected entity.

Think of it this way: your e-commerce platform isn't just your Order Management API. It's also your Customer Profile API, your Payments Service, your Inventory Engine, and however many other services are involved. Together, those repositories are your system. DeCoder now understands that.

Setting Up a System

Getting started is straightforward. From the Systems section of DeCoder, you create a new System, give it a name, and attach whichever repositories belong to it. Once linked, you can trigger a full System Analysis with a single click.

The Systems dashboard showing the Shopping Demo system with linked repositories — OrderManagementAPI and CustomerProfileAPI. DeCoder then goes to work across all of the attached codebases simultaneously, building a unified picture of your architecture.

What the Analysis Reveals

When the analysis completes, you're presented with an aggregated report broken down into several key categories.

Duplicate Functions and Classes

DeCoder identifies functions and service classes that exist in more than one repository. These are prime candidates for extraction into a shared library — and left unaddressed, they become a maintenance burden every time the underlying logic needs to change.

In the Shopping Demo example above, the analysis surfaced 7 duplicate functions and 4 duplicate services or classes across just two repositories. In a larger system, the numbers can be considerably higher.

Common Patterns and Shared Dependencies

Beyond outright duplication, DeCoder identifies structural patterns that recur across repositories — similar architectural approaches, shared dependency trees, or common implementation strategies. This shared-pattern intelligence helps engineering teams spot opportunities for standardisation and understand where codebases have naturally converged (or diverged) in their design.

Cross-Repo API Matches

This is one of the most powerful aspects of the System analysis. DeCoder detects API endpoints across repositories that share path segments, parameter structures, or functional intent — surfacing potential integration points, redundant implementations, or undocumented service-to-service dependencies that might not be obvious from reading any single codebase.

Aggregated Code Smells

Code smells identified within individual repos are rolled up into a single, system-wide view. This gives engineering leaders and architects a top-level quality signal across the entire system, not just repo by repo.

Two Ways to Explore Your System

Once the analysis has run, you can explore the results in two complementary ways.

The Report View

The default view presents all findings in a clean, structured report — grouped by category, with counts and expandable detail for each finding. It's designed for review sessions, team discussions, and feeding directly into technical backlog planning.

The Systems analysis report showing the category breakdown — Duplicate Functions (7), Duplicate Services/Classes (4), Common Patterns (1), Cross-Repo API Matches (5), Aggregated Code Smells (4)]

The System Graph

For those who prefer a more visual way to reason about architecture, the System Graph renders your entire system as an interactive node graph. Repositories, files, classes, functions, API endpoints, and packages are all represented as nodes, with edges showing the relationships between them — including the cross-repo connections that the analysis has identified.

You can filter the graph by node type, search for specific nodes, and click into any element to open the Inspector panel. The Inspector gives you contextual detail about whatever you've selected — including, for API endpoints, a plain-English summary of what the endpoint does, its file quality score, complexity rating, and any cross-repo API matches it has been associated with.

The system graph with 109 nodes and 118 edges in the Shopping Demo alone, the graph makes it easy to spot clusters, outliers, and the connective tissue between services that would be completely invisible when looking at repositories individually.

Why This Matters

Modern software is built as systems, not as individual repositories. Yet until now, most code analysis tooling has been constrained to operate at the repository level — leaving architects and senior engineers to do the cross-cutting analysis in their heads, in spreadsheets, or not at all.

Systems changes that. It brings the same depth of analysis that DeCoder applies within a single codebase and extends it across your entire architecture — giving you a clear, evidence-based view of duplication, coupling, shared patterns, and quality issues at the system level.

Whether you're planning a shared-library extraction, onboarding onto a new codebase, preparing for a migration, or simply trying to understand the shape of what you've built, Systems gives you the complete picture.

Getting Started

Systems is available now in DeCoder. Head to the Systems section from the main navigation, create your first System, attach your repositories, and run your first cross-repo analysis.

If you've got questions or want to see a walkthrough, drop into the Chat from within DeCoder or reach out to the team directly.

DeCoder — understand your codebase, at any scale.