Code Quality Showdown: OpenAI Codex vs Google Gemini CLI vs OpenCode

The Contenders

All three are actively developed, similarly sized codebases (~400-440K LOC). What separates them is everything under the hood.

Score Breakdown by Category

Each category is scored 0-100. Higher is better.

Issue Density: Rust vs TypeScript

Codex has 6-8x fewer issues per line of code than both TypeScript projects. This is partly Rust's strict compiler catching problems at build time that surface as analysis findings in TypeScript. Rust's ownership model, exhaustive pattern matching, and strong type system eliminate entire categories of bugs before they reach production.

Issue Severity

Zero high-severity issues for Codex. Gemini CLI has the most, with 32 high-severity findings -mostly in testing (7) and code smells (25).

Where the Issues Live

Consistency is where Gemini CLI and OpenCode bleed points. With 2,734 consistency issues, Gemini CLI's score in this category drops to just 16/100.

OpenCode has the most runtime risk issues (277) -4.4x more than Gemini CLI, pulling its runtime risks score down to 50/100.

Where the Findings Come From

The static analyzer numbers deserve context -and honesty about our methodology.

What's Driving the Numbers

The top Biome findings across both TypeScript projects:

Some of these are stylistic preferences (literal keys, template strings). Others are genuine code quality signals -particularly noExplicitAny and noUnusedVariables.

To see what 332 any uses actually look like in practice, here's a function from OpenCode's OpenAI provider adapter:

export function fromOpenaiRequest(body: any): CommonRequest {
  if (!body || typeof body !== "object") return body

  const toImg = (p: any) => {
    if (!p || typeof p !== "object") return undefined
    if ((p as any).type === "image_url" && (p as any).image_url)
      return { type: "image_url", image_url: (p as any).image_url }
    if ((p as any).type === "input_image" && (p as any).image_url)
      return { type: "image_url", image_url: (p as any).image_url }
    const s = (p as any).source
    if (!s || typeof s !== "object") return undefined
    if ((s as any).type === "url" && typeof (s as any).url === "string")
      return { type: "image_url", image_url: { url: (s as any).url } }
    if (
      (s as any).type === "base64" &&
      typeof (s as any).media_type === "string" &&
      typeof (s as any).data === "string"
    )
      return {
        type: "image_url",
        image_url: { url: `data:${(s as any).media_type};base64,${(s as any).data}` },
      }
  }

That's 15+ as any casts in a single function. The parameter p is already typed any, so every (p as any) is redundant -and the nested (s as any) casts show a lack of type narrowing. A single interface definition would eliminate all of these and catch shape mismatches at compile time.

This pattern extends beyond business logic into core utilities. Here's OpenCode's logging module:

export namespace Log {
  const ctx = Context.create<{
    tags: Record<string, any>
  }>()

  export function create(tags?: Record<string, any>) {
    const result = {
      info(message?: any, extra?: Record<string, any>) {
        const prefix = Object.entries({
          ...use().tags,
          ...tags,
          ...extra,
        })
          .map(([key, value]) => `${key}=${value}`)
          .join(" ")
        console.log(prefix, message)
        return result
      },
      // ...
    }
  }
}

Five any types in a 55-line file. The tags, message, and extra parameters could all be typed -Record<string, string | number | boolean> would cover most logging use cases. When any lives in core utilities, it propagates through every callsite.

What Their Own Linters Say

We dug into each project's linting setup. The contrast is striking.

Testing: A Tale of Three Philosophies

Gemini CLI has a staggering 64.6% test-to-code ratio -nearly two-thirds of the codebase is test code. It also has the highest structural coverage at 45.3%, backed by 738+ test files. Google's testing culture shows.

Codex writes fewer but denser tests. Despite lower coverage numbers, Codex's assertion density (1.22 assertions per test function) is 4-5x higher than either TypeScript project. Fewer tests, but each one validates more.

OpenCode has the weakest test story at 8.3% test ratio and only 10.1% structural coverage, with near-zero mock usage (0.6%). This is a real risk area as the project scales.

Architecture Quality

All three received a B architecture rating, but the dimension scores reveal different strengths:

Gemini CLI leads in every architecture dimension. Its monorepo structure with dedicated packages demonstrates Google's experience building large-scale TypeScript applications. The policy engine, hook system, and declarative tool abstractions are standout patterns.

That said, even Gemini CLI has structural debt. Our graph analysis flagged the ClearcutLogger class as a god class -a single telemetry class spanning 1,941 lines:

// 1,941 lines, 61 methods
export class ClearcutLogger {
  private static instance: ClearcutLogger;
  private config?: Config;
  private sessionData: EventValue[] = [];
  private promptId: string = '';
  private readonly installationManager: InstallationManager;
  private readonly userAccountManager: UserAccountManager;
  private readonly hashedGHRepositoryName?: string;

  private readonly events: FixedDeque<LogEventEntry[]>;
  private lastFlushTime: number = Date.now();
  private flushing: boolean = false;
  private pendingFlush: boolean = false;
  // ... 61 methods follow
}

Similarly, their Storage class (403 lines, 54 methods) handles everything from session management to OAuth token paths to plan directories. Both are candidates for decomposition.

Codex's Rust workspace with 70+ crates is impressive in granularity, though the core crate has grown into a monolithic hub. The main codex.rs file is 7,226 lines with 54 public functions -it's the central nervous system that everything routes through. This is the primary architectural concern our graph analysis flagged.

OpenCode's 20+ package monorepo is well-structured with an event bus pattern and multi-platform support (CLI, web, desktop, cloud), but large files and cross-module dependencies create maintenance pressure.

Architectural Highlights

Codebase Dynamics

OpenCode's 48% refactoring rate is the standout number here -almost half of recent changes are refactors rather than new features. This signals a team actively investing in codebase quality, even without formal lint tooling. It's the kind of organic discipline that's hard to fake.

Gemini CLI's near-zero churn and refactoring is unusual -possibly reflecting a stable initial architecture or a recent major release that reset activity metrics. Their 92.6% convention consistency is the highest of the three, with only 13 deviations detected.

Key Takeaways

Methodology

Each project was analyzed using Octokraft's full analysis pipeline, which combines three detection layers:

On top of these, Octokraft runs convention detection, architecture review, and health scoring across 8 weighted categories.

All analyses were run against the latest commit on the default branch as of March 11, 2026.