OrbitCTO-X

The Problem

Modern AI coding assistants are great at generating code, but they often make architectural recommendations without understanding the repository they're working on.

A developer might ask:

"How should I add OAuth?"

"What's the best way to implement multi-tenancy?"

"Should I split this service?"

Most AI assistants immediately provide an answer.

The problem is that these recommendations are frequently based on assumptions rather than repository evidence.

They may suggest services that don't exist, ignore architectural constraints, invent dependencies, or recommend migrations that don't fit the codebase.

This creates a new developer pain point:

AI hallucinations at the architecture level.

Developers spend time validating recommendations, correcting wrong assumptions, and recovering from design decisions based on incomplete context.

Our Solution

We built OrbitCTO-X, a repository-aware engineering decision agent powered by GitLab Orbit.

Instead of immediately generating an answer, OrbitCTO-X investigates the repository first.

Using GitLab Orbit tools, it gathers evidence about:

Repository structure Existing services Dependencies Architectural boundaries Historical implementation patterns Project context

It then generates multiple implementation strategies and performs a structured tradeoff analysis.

Most importantly, OrbitCTO-X explicitly separates:

✅ Verified repository facts

⚠️ Partially verified findings

❌ Unsupported assumptions

This allows developers to see exactly what is known versus what the AI is inferring.

The Developer Experience

Before OrbitCTO-X:

A developer asks:

"How should I implement OAuth?"

The AI immediately suggests a solution that may not match the repository architecture.

The developer must manually verify every recommendation.

After OrbitCTO-X:

The developer asks the same question.

OrbitCTO-X first analyzes the repository using GitLab Orbit.

It identifies what actually exists in the codebase, generates multiple implementation approaches, evaluates their tradeoffs, and provides recommendations backed by repository evidence.

The developer receives:

Architecture recommendations grounded in repository context Multiple viable implementation strategies Explicit hallucination prevention through evidence verification Risk assessment and rollback planning Confidence scoring for every recommendation