How Ramp's Engineering Team Uses Codex to Accelerate Code Review: From Hours to Minutes

The Efficiency Bottleneck of Code Review: Why Engineers Are Always Waiting for Feedback

In modern software development workflows, code review is a critical step for ensuring code quality—but it's also the number one bottleneck slowing down delivery. Code review originated from IBM's "Fagan Inspection" methodology in the 1970s, initially a formal software defect detection process. With the rise of Agile development and DevOps, modern code review has evolved into an asynchronous collaboration model based on Pull Requests. According to Google's internal research, engineers spend an average of 35% of their day on code review-related activities, while Microsoft's research shows that the median time from PR submission to merge exceeds 24 hours.

After submitting a Pull Request, engineers often wait hours or even an entire day before receiving feedback from colleagues—this dead time not only wastes productivity but frequently interrupts developers' flow state. The "Flow State" here isn't just a buzzword: psychologist Mihaly Csikszentmihalyi's research shows that entering deep focus requires approximately 15-20 minutes, and a single context switch can cost an engineer over 23 minutes of effective work time. Waiting for code review feedback is essentially a forced context switch.

Fintech company Ramp's engineering team found a pragmatic solution: combining OpenAI's Codex with GPT-5.5 to build an AI-driven code review workflow that compresses the wait time for substantive feedback from hours to minutes.

Codex + GPT-5.5: How AI Code Review Works

From Passive Queuing to Instant Feedback

Traditional code review relies entirely on humans—reviewers need to understand business context, read changes line by line, and consider potential risks. This process is inherently time-consuming. After Ramp's team introduced Codex, engineers can receive AI's preliminary review comments the moment they submit their code.

OpenAI Codex is a large language model fine-tuned specifically for code tasks based on the GPT architecture, originally launched in 2021 as the underlying engine for GitHub Copilot. Compared to general-purpose language models, Codex's training data includes a massive amount of public code repositories from GitHub, giving it deep understanding of syntax, idiomatic patterns, and common errors across multiple programming languages. The new generation of Codex combined with GPT-5.5 brings significant improvements in reasoning capabilities, enabling it to understand cross-file dependencies, identify complex bugs like async race conditions, and evaluate algorithmic complexity.

The fundamental difference from early static analysis tools (like ESLint and SonarQube) lies in this: the latter perform pattern matching based on predefined rule sets, while Codex can perform semantic-level understanding and reasoning, handling edge cases that rules cannot cover. Therefore, leveraging GPT-5.5's reasoning capabilities, Codex provides not just syntax and style checks, but truly "substantive feedback." Specifically, it can point out logical flaws, performance risks, and architectural improvement directions like an experienced senior engineer—far exceeding the capabilities of traditional lint tools.

The Cascading Effects of Minute-Level Response Times

Compressing the feedback cycle from hours to minutes creates value far beyond time savings alone:

• Eliminating context-switching costs: Engineers don't have to switch to other tasks while waiting for review, nor spend 20-30 minutes re-entering their previous code state
• Accelerating iteration cycles: Fast feedback means issues can be fixed on the spot and resubmitted, completing in one day what previously took two or three days of iteration
• More consistent review standards: AI won't relax its checking standards due to 3 PM fatigue or deadline pressure

Engineering Practice: AI-Assisted Rather Than AI-Replaced Human Review

A Layered Human-AI Collaboration Model

Ramp's approach isn't about replacing human review with AI, but positioning it as the "first line of defense" in the review process. There's a deep engineering philosophy behind this design. "Human-in-the-Loop" (HITL) is a core safety principle in AI system design, especially indispensable in high-risk decision-making scenarios. In the fintech space, this principle is also subject to regulatory constraints—the U.S. OCC (Office of the Comptroller of the Currency) and SEC both have explicit human oversight requirements for algorithmic decision systems.

From a cognitive science perspective, this division of labor is equally sound. Nobel laureate Daniel Kahneman's "dual-system theory" notes that the human brain's "System 1" (fast, automatic) and "System 2" (slow, deliberate) each have appropriate use cases. Having AI handle "System 1" type high-frequency routine checks while letting humans focus on complex judgments requiring "System 2" is a division of labor aligned with cognitive principles.

The specific collaboration works as follows:

1. AI handles routine checks first—code style, common bug patterns, performance anti-patterns, etc.
2. AI provides preliminary logical analysis and improvement suggestions
3. Human reviewers, building on AI feedback, focus on higher-level judgments—architectural soundness, business logic correctness, security compliance, etc.

The benefits of this layered model are obvious: human reviewers are freed from repetitive labor and can invest their limited attention where human judgment is truly needed. For a fintech company like Ramp, where code quality directly relates to fund security and regulatory compliance, human review remains indispensable—but its efficiency and focus are both enhanced.

Practical Takeaways for Other Engineering Teams

Ramp's case reflects an accelerating industry trend: AI is extending from "assisting with writing code" to the full process of "assisting with managing code quality." From GitHub Copilot helping you write code to Codex helping you review code, AI's role in software engineering is becoming increasingly systematic.

Teams looking to replicate this practice can consider the following approaches:

1. Choose the right entry point: Code review is high-frequency, time-consuming, and has clear good/bad criteria—making it an ideal starting point for AI intervention
2. Pursue deep feedback: Don't use AI as a mere format checker; fully leverage large models' reasoning capabilities for deep-level analysis
3. Maintain human-in-the-loop: Especially in high-risk domains like finance and healthcare, AI should assist judgment but not make final decisions

Looking Ahead: Where AI-Driven Development Workflows Are Heading

The trend of AI participating across the full software development lifecycle can be traced back to the rise of the "AIOps" concept around 2018, but the real acceleration happened after the large language model capability breakthrough in 2022. The industry currently categorizes AI applications in software engineering into several maturity levels: code completion (represented by GitHub Copilot), code generation (represented by Cursor and Devin), code review (represented by the Ramp case), and autonomous software engineering (research directions like SWE-agent).

It's worth noting that "AI code review" is fundamentally different from "automated testing": testing verifies whether code runs as expected, while review evaluates whether code solves the right problem in the right way—the latter demands a higher level of semantic understanding, which is precisely where large language models excel. According to McKinsey's 2023 research, AI-assisted programming can boost developer productivity by 20-45%, but this figure may be even more significant for code review, given the higher degree of standardization in review work.

As next-generation models like GPT-5.5 continue to advance in code comprehension and logical reasoning, AI's depth of participation across the full software development lifecycle will continue to grow. Code review is just one of the most mature deployment scenarios today; we'll likely see AI playing more central roles in requirements analysis, automated test generation, production incident troubleshooting, and other stages.

Ramp's practice sends a clear signal: deeply integrating AI tools with existing engineering workflows can deliver significant efficiency gains without disrupting team habits. This may be the most pragmatic path for AI engineering adoption at the current stage—not pursuing end-to-end full automation, but achieving intelligent acceleration at critical bottleneck points.