How LeoLabs scales Orbital Intelligence with CodeRabbit
LeoLabs uses CodeRabbit to keep code quality and security aligned with AI-assisted development while meeting strict defense governance requirements.
CASE STUDY54.9% comment acceptance rate
Cross-repository context reduced false positives
Latent edge-case bugs found before they caused failures
Strict defense model-provider mandates satisfied
LeoLabs is no stranger to high-velocity development in a domain where precision is paramount. As a leading player in Space Domain Awareness (SDA) and Space Traffic Management (STM), LeoLabs builds ground-based radars across the globe to track tens of thousands of objects in orbit. Engineering velocity and rigorous quality are critical.
With a cloud software team supporting real-time tracking, trajectory prediction five days out, and satellite characterization for U.S. and Allied defense agencies, it is essential to deliver features quickly while maintaining strict standards.
However, scaling software output introduced a core challenge: ensuring code quality and security kept pace with accelerated code generation. That urgency led LeoLabs to evaluate AI code review solutions. After a detailed proof-of-concept trial, the team chose CodeRabbit for its contextual understanding, high-signal feedback, and defense-compliant governance.
Challenge: Balancing speed, quality, and governance
Before adopting CodeRabbit, LeoLabs faced key challenges as it scaled its cloud software capabilities.
Maintaining standards under accelerated code output
AI-assisted code generation increased developers' output, but maintaining the team's quality standards required an equivalent leap in review capabilities. With an ambitious product roadmap for the Delta orbital threat detection and characterization system and a tight resource budget across multiple defense contracts, the engineering team needed a scalable way to uphold quality and security.
“If I tell my team to write four times as much code using AI, but the quality stays constant, then we're going to push four times as many bugs, have four times as many outages. If we want to go four times faster, we actually need four times better quality at least.”
Matthew Stevenson, SVP of Software Engineering at LeoLabs
Preventing costly escaped defects in defense systems
Fixing bugs in production is costly, particularly when supporting critical defense and intelligence missions. To catch issues early without overloading engineers, LeoLabs sought agentic AI code review tools to augment its mandatory human code reviews.
Why CodeRabbit
Review quality without the noise
LeoLabs approached the selection methodically, testing three approaches: CodeRabbit, a competing vendor tool, and an in-house agentic review tool built using its own LLM tokens and prompt instructions. The team evaluated each option across a decision matrix covering cost, maintenance effort, review quality, and governance.
CodeRabbit stood out because of its high signal-to-noise ratio and relevant commentary. “There isn't a single comment that made us feel that CodeRabbit is clearly the best option. Rather, it’s the overall quality of the comments paired with features that allow the team to work effectively,” explained Daniel Kim, Senior Staff Software Engineer at LeoLabs. Features like inline chat, learnings, and comment source transparency allowed engineers to treat CodeRabbit as a collaborator rather than just a reviewer.
Multi-repository awareness
CodeRabbit differentiated itself by tracking context across separate repositories. In one trial instance, a competing tool flagged a false positive on a modified interface because it could not see the related repository. CodeRabbit evaluated both repositories, recognized the interface consistency, and cleared the change.
Lower long-term maintenance overhead
Although LeoLabs successfully prototyped an in-house review agent, leadership recognized that maintaining custom prompts and tool architecture over time would consume critical engineering resources.
Strict defense governance and vendor flexibility
Due to defense procurement requirements, LeoLabs faced a strict mandate that required software vendors to exclude specific model providers. Many other AI vendors were unable to clear this procurement hurdle, a blocker affecting roughly a quarter of software vendors LeoLabs evaluates. CodeRabbit worked directly with LeoLabs to redline the contract and enforce an OpenAI-only setup.
“Any of us can vibe code a tool these days, but the sustained expertise and thoughtfulness on how well the tool works is important. We believe that we would get better long-term performance if we went to an outside vendor.”
Matthew Stevenson, SVP of Software Engineering at LeoLabs
CodeRabbit gives LeoLabs a high-signal review layer that fits its engineering workflow and defense governance requirements.
54.9%
comment acceptance rate
Cross-repo
context for more accurate reviews
OpenAI-only
setup for defense governance
Implementation: Contextual guardrails and uncovering latent bugs
Custom architecture and language instructions
LeoLabs set up per-language instruction files across Python, Go, TypeScript, Terraform, and Terragrunt, along with architectural guidelines. CodeRabbit explicitly attributes comments to these instruction files, giving reviews immediate authority. “Knowing that the comment is the result of an instruction file gives it more weight and importance to the engineer,” noted Daniel. To streamline maintenance across repositories, the team uses centralized references to instruction files.
Catching latent production bugs
CodeRabbit's deep analysis helped identify critical logic edge cases that traditional checks missed.
“We have found bugs in our upgraded AI tooling that had been latent in our code. One example concerned a rare edge case that was failing silently. CodeRabbit noticed the issue, and we were able to remedy it.”
Matthew Stevenson, SVP of Software Engineering at LeoLabs
Results: Higher confidence and engineering alignment
CodeRabbit streamlined LeoLabs' pull request workflows without adding noticeable latency for developers. Syntax and style feedback is automated, allowing human reviewers to focus on high-level architecture and logic. The implementation also satisfies LeoLabs' strict defense procurement and model-provider mandates.
By integrating CodeRabbit into its development workflow, LeoLabs expanded its software capabilities while upholding strict quality and security guardrails. “I've been happy that the team is visibly excited to be using this new tool,” shared Matthew. “People are excited for this one.”
High-velocity development with quality and governance built in
Before CodeRabbit
- Code reviews relied solely on human reviewers, creating potential bottlenecks as AI code generation increased output.
- In-house and competing tools generated excess noise or false positives on cross-repository dependencies.
- Latent edge-case bugs remained hidden in legacy code.
After CodeRabbit
- LeoLabs achieved a 54.9% comment acceptance rate.
- Pull request workflows moved faster without adding noticeable latency for developers.
- Automated syntax and style feedback lets human reviewers focus on high-level architecture and logic.
- The deployment fully complies with strict defense procurement and model-provider mandates.
Industry
Space domain awareness and space traffic management
Challenge
Maintain code quality and security as AI-assisted output accelerates under strict defense governance requirements
