Evaluating CodeRabbit? Same review, plus real test runs. See why

Automation Testing22 min read

Gemini 4 Neon vs Opus 5.5 vs GPT-6.2 Sol: Which Is the Best AI Code Reviewer?

S
Founder, Qodex
A planted bug where forEach runs async callbacks that nobody awaits, and the result for three reviewers: Gemini 4 Neon caught it, Claude Opus 5.5 caught it, GPT-6.2 Sol missed it

Which is the best AI for code review: Gemini 4 Neon, Claude Opus 5.5 or GPT-6.2 Sol? No model wins everything. Gemini 4 Neon found the most bugs. Claude Opus 5.5 was about twice as fast as the other two. GPT-6.2 Sol was the cheapest, and also the noisiest. We ran 336 scored code reviews, on planted bugs and on 35 real open-source pull requests.

Most comparison posts quote the vendors' numbers or run one or two small prompts. This one records the time and the cost of every review.

This is a code review benchmark, not a coding benchmark. All three ran at medium effort inside OpenQodex, the open-source pre-push reviewer we build at Qodex. So the results measure each model plus our pipeline. If you want this kind of review on your own pull requests, connect a GitHub repository to Qodex PR review.

The short answer

At medium effortGemini 4 NeonClaude Opus 5.5GPT-6.2 Sol
Planted bugs found, of 102 chances10210197
Human review comments matched, 35 real pull requests17.3%12.6%14.6%
False alarms on clean code, of 4 chances002
Real pull request findings that matched no human comment69.3%73.1%87.3%
Time per planted review, mean148 s65 s127 s
List price per planted review$0.57$0.52$0.29

Bold marks the best in each row. Every dollar here is a list price: what the same tokens would cost on a paid API key. Nobody paid it, because all three tools ran on subscription logins.

Gemini 4 Neon vs Opus 5.5 at a glance

Neon found 102 of 102 planted-bug chances to Opus's 101, and matched 17.3% of human review comments to Opus's 12.6%. Opus was about 2.3 times faster on planted bugs (65 seconds against 148) and a little cheaper per review ($0.52 against $0.57). Per matched human comment, Neon was the cheaper one: $1.47 against $1.77.

GPT-6.2 Sol vs Opus 5.5 at a glance

Sol cost $0.29 per planted review against $0.52 for Opus, and $0.98 per matched human comment against $1.77. Opus found more planted bugs (101 against 97), raised no false alarm on clean code where Sol raised 2, and took 65 seconds a review against 127. On real pull requests, 87.3% of Sol's findings matched no human comment, against 73.1% for Opus.

What the launch posts claimed

Excerpt from Google's Gemini 4 Neon launch post, highlighting the claim that Neon ranks number 1 overall on the Artificial Analysis Coding Agent Index with a score of 58.6
From Google's launch post, highlight ours. Source: blog.google, Introducing Gemini 4 Neon, captured 22 Nov 2026.

All three models launched within about two months of each other: Claude Opus 5.5 from Anthropic on 22 September 2026, GPT-6.2 Sol from OpenAI on 17 November, and Gemini 4 Neon from Google on 18 November.

Google's launch post says Neon ranks first overall on the Artificial Analysis Coding Agent Index, with a score of 58.6. The same post lists 65.2% on Terminal-Bench 4.1 and 46.2% on FrontierCode 2.0. Those are coding scores. The post makes no claim about code review, which is a different job: find what is wrong in a change, and stay quiet when nothing is.

Artificial Analysis chart of Intelligence Index against cost per task, with three models ringed: GPT-6.2 Sol at 57 for 1.01 dollars a task, Gemini 4 Neon at 61 for 6.44 dollars, Claude Opus 5.5 at 59 for 10.04 dollars
Intelligence Index against cost per task, each model at its highest effort. The coloured rings and labels are ours. Source: artificialanalysis.ai/models/gemini-4-neon, chart cropped, read 22 Nov 2026.

Artificial Analysis gives each model an Intelligence Index score and a cost per task. At its highest effort, Neon scores 61 at $6.44 a task, Opus 5.5 scores 59 at $10.04, and Sol scores 57 at $1.01. At medium effort, the setting we tested, the same page lists Neon at 55 and Opus 5.5 at 48.

That sets an expectation: Neon should review at least as well as Opus, for less money. The rest of this post checks it.

How we tested

Test design in three boxes: the code (51 bugs planted in 19 small repos, plus 2 clean repos with no bug, 35 real pull requests with 256 human comments), the reviewers (Gemini 4 Neon, Claude Opus 5.5, GPT-6.2 Sol, two reviews of every case at medium effort) and the score (336 scored reviews, fixed rules for planted bugs, a judge model for real pull requests)
The test design: the code, the reviewers and the score.

Every model ran through OpenQodex 0.22.0. It runs rule-based scanners on the change, such as semgrep and gitleaks, and builds a code graph: a map of which code calls which. Then it starts the model's own command line tool on a read-only copy of the repository. Two finder sessions read each part of the change, and verifier sessions confirm or drop each candidate.

Every model got the same brief, scanner hits, code graph and review stages. Only the tool and the model changed:

ModelMakerToolEffort
Gemini 4 NeonGoogleAntigravity CLI 1.5.13Medium (part of the model id)
Claude Opus 5.5AnthropicClaude Code 2.1.330Medium, requested (Claude Code does not report it back)
GPT-6.2 SolOpenAICodex 0.171.0Medium

Web search was off, and writes and shell commands were denied. All reviews ran on one Apple M5 Pro Mac, with a limit of 1,800 seconds per review.

The planted set. 51 bugs planted in 19 small repos, plus 2 clean repos with no bug, all written for this benchmark: 21 cases in total. The bugs are 18 critical, 27 major and 6 minor. Fixed rules do the scoring: a finding counts only when it sits on the right lines, names the right kind of problem and uses one of the expected words.

The real pull requests. 35 pull requests from AACR-Bench, a public benchmark by Alibaba, across 10 languages and 8,104 changed lines. The answer key is the 256 comments that human reviewers left on them. A finding has to sit within 1 line of a human comment, then a judge model, GPT-5.2, decides whether the two say the same thing, averaged over 3 rounds.

Each model reviewed every case twice. That is 42 planted reviews and 70 real pull request reviews per model, and 336 scored reviews across the three models. The runs took place on 21 and 22 November 2026.

This AI code review benchmark measures bugs found, false alarms, agreement with human reviewers, and the time and list price of each review. It does not measure how well a model writes code, other effort levels, or other pipelines.

Which AI model finds the most real bugs in code review?

Grid of squares, one per planted bug per repeat: Neon found 102 of 102 with no misses, Opus found 101 with 1 miss, Sol found 97 with 5 misses, including the forEach bug in both repeats
Planted bugs found. One square is one bug in one repeat. A red outline is a miss.

51 bugs, each reviewed twice, make 102 chances. Neon found all 102. Opus found 101. Sol found 97. On the critical and major bugs alone, 90 chances, the counts were 90, 89 and 85.

Keep the scale in mind. Only 5 chances out of 102 separate first from last, and the 95% intervals overlap: 100% to 100% for Neon, 96% to 100% for Opus and 86% to 100% for Sol. Read the order as a hint, not a ranking.

The scanners did not do all the work: 38 of the bugs Opus found, 36 of Sol's and 38 of Neon's had no scanner hit pointing at them. All three found all 12 bugs that need the code graph.

Sol's 5 misses come from 3 bugs. It missed a forEach bug in both repeats, a publicly reachable database in both repeats, and a spoofable Dependabot check in repeat 2. The database is a near miss: Sol filed it as "Public RDS setting in private subnets", a configuration bug, arguing the database could not be reached. Wrong kind of problem, so the scorer counts a miss.

Proof: Sol never writes about the forEach

Planted bug in an Express admin route where ids.forEach runs async removeUser calls that nobody awaits. Opus and Neon caught it in both repeats. Sol missed it in both and only reported an HTTP 403 on the purge route
Proof 01. A planted bug in an Express admin route. Finding text is quoted from each review.

forEach does not wait for async callbacks, so the route answers before any user is removed. Opus and Neon name the unawaited promise in both repeats. Sol's only finding on this route is "HTTP 403 for every bulk purge request", and it never mentions forEach or await.

Proof: Opus's one miss may be a scorer error

Planted bug in a Postgres migration: CREATE INDEX without CONCURRENTLY on the orders table. Opus's repeat 2 finding, Index build blocks writes to orders, names the lock and the CONCURRENTLY fix but was scored as a miss
Proof 02. A planted Postgres migration bug, and the Opus finding scored as a miss in repeat 2.

The planted bug is a CREATE INDEX without CONCURRENTLY. In repeat 2 Opus wrote "Index build blocks writes to orders", naming the lock and the CONCURRENTLY fix, but the scorer filed it under a side issue. In repeat 1 the same finding counted as caught. This may be a scorer error. We keep the number at 101 because nobody has ruled on it.

Which model stays quiet on clean code?

Two clean changes, a Python feature and a TypeScript refactor, each reviewed twice. Neon and Opus raised 0 false alarms. Sol flagged the Python feature in both repeats, 2 false alarms
Clean changes. One square is one review. A red outline is a false alarm.

2 of the planted cases are clean, reviewed twice each, so every model had 4 chances to stay quiet. Opus and Neon said nothing all 4 times. Sol flagged the clean Python change once in each repeat.

Range bars for the share of planted findings that were right: Opus at least 85.0% and at most 100% with 31 findings not ruled on, Neon 83.3% to 100% with 37, Sol 64.2% to 99.2% with 89. Only 2 of 254 Sol findings were ruled wrong
Share of each model's planted findings that were right, as a range. Solid dot: every finding nobody has ruled on counts as wrong. Ring: those findings count as right.

On the planted set Opus wrote 207 findings, Neon 221 and Sol 254. The scorer rules a finding right when it hits a planted bug or a listed side issue, and wrong when it lands on a clean change. Everything else waits for a person, and no person has ruled yet: 31 open findings for Opus, 37 for Neon and 89 for Sol.

So each model gets a range. Count every open finding as wrong, and Opus is right at least 85.0% of the time, Neon 83.3% and Sol 64.2%. Count them as right, and Opus and Neon reach 100% and Sol 99.2%. Combined with recall, the lower-bound F1 score is 0.91 for Opus, 0.91 for Neon and 0.77 for Sol.

Do not read Sol's 64.2% as "wrong a third of the time". Only 2 of Sol's 254 findings were ruled wrong, both on the same clean change.

Proof: Sol's false alarm is an extreme edge case

A clean Python money formatter and its caller. Opus and Neon gave no finding in either repeat. Sol reported Statement formatting failure for oversized totals, about a 4,301-digit balance, and it was ruled wrong in both repeats
Proof 03. A clean change: a small, correct money formatter.

The change is a small, correct money formatter. Sol found a way to break it: a balance with 4,301 digits, which Python refuses to format. The edge case is real but very remote. We would call it an extreme edge case, not a hallucination.

Does the model rate severity right?

Planted React bug where useState and useEffect run after an early return. All three models caught it in both repeats. Opus and Sol rated it major, as the case does. Neon rated it critical
Proof 04. A planted React hooks bug. The case rates it major.

Here, React hooks run after an early return. All three found it in both repeats. Opus and Sol rated it major, as the case does. Neon rated it critical both times. Either rating is defensible for a crash.

Bars of found planted bugs rated lower, higher or the same as the case: Neon 4 lower, 30 higher, 68 of 102 the same; Opus 10 lower, 21 higher, 70 of 101 the same; Sol 19 lower, 11 higher, 67 of 97 the same
Found planted bugs that each model rated lower or higher than the case says, over both repeats.

Over every planted bug each model found, Neon rated 30 higher than the case and 4 lower. Opus rated 21 higher and 10 lower. Sol rated 11 higher and 19 lower. Most upward moves are major bugs called critical: Neon did that 29 times, Opus 21 and Sol 11. Sol leans the other way and lowered 11 critical bugs to major, where Opus and Neon lowered 2 each.

One planted case commits a live payment secret key to the repository (a fake key we wrote for the test). Opus and Neon called it critical. Sol called it major in both repeats.

Severity is the benchmark author's call, so read this as a tendency. If every critical finding pages someone, Neon will page them more often, and Sol may let a real critical slip into the major pile.

Which model matches what human reviewers said?

Bars of the share of 256 human review comments each model matched: Neon 17.3%, Sol 14.6%, Opus 12.6%
Share of the human review comments each model matched. 256 comments on 35 pull requests, checked in both repeats.

Planted bugs are tidy. Real review is not. On the 35 real pull requests, Neon matched 17.3% of the human comments, Sol 14.6% and Opus 12.6%. On precision, the share of each model's findings that matched a human comment, the order was Neon 30.7%, Opus 26.9% and Sol 12.7%. The F1 scores were 0.22, 0.17 and 0.14.

Low numbers are expected: humans also comment on style, such as "Extract this as a named constant". No model matched any comment on the Rust pull requests. By language, Neon did best on C, at 26.9%, and Opus on Java, at 29.5%.

A match looks like this. The human wrote "When a DBCException is caught, it's only logged but not re-thrown". Neon wrote "Swallowed DBCException in setDefaultCatalog ... It never rethrows DBCException to the caller."

Proof: a nil check only Neon wrote down

ollama pull request 9746: a human reviewer flags that Close dereferences a nil file. Neon's finding, Chunker.Close returns os.ErrInvalid for pre-validated blobs, matched in 6 of 6 judge rounds. Opus and Sol flagged other problems in the same file
Proof 05. ollama pull request 9746. The first row is the human reviewer's comment.

A human reviewer pointed at a missing nil check in Close. Neon wrote the same thing, and the judge matched it in all 6 rounds. Opus and Sol both flagged this file, but for a different problem.

Proof: same bug, different line, different score

lvgl pull request 8689: an array is allocated one element short on line 293 and written past its end on line 309. The human comment sits on line 293. Neon's finding covers lines 293 to 309 and matched. Sol reported the same overflow at line 309 and did not count
Proof 06. lvgl pull request 8689. The first row is the human reviewer's comment.

Scoring rules matter. All three models saw this heap overflow. The human comment sits on line 293, where the array is allocated. Neon's finding covers lines 293 to 309, so it matched in 6 of 6 rounds. Sol reported the same overflow at line 309, where the bad write happens, and a finding must sit within 1 line of the human comment, so it did not count. Opus found it in repeat 1 only.

That one C pull request carries much of Neon's lead. With it, the judge counted 88.33 matches for Neon over both repeats, 75.00 for Sol and 64.33 for Opus. Without it, the totals are 65.67, 61.0 and 54.33. Neon still leads, by less.

More findings did not mean more matches

Findings per review on real pull requests: Sol 8.49 per review, 594 in all, 87.3% matched no human comment; Neon 4.19, 293 in all, 69.3%; Opus 3.44, 241 in all, 73.1%
Findings per review on real pull requests. Solid: findings that matched a human comment. Outline: the rest.

Sol wrote 594 findings on the real pull requests, more than Opus (241) and Neon (293) together. That is 8.49 findings per review, against 4.19 for Neon and 3.44 for Opus. 87.3% of Sol's findings matched no human comment, against 73.1% for Opus and 69.3% for Neon.

An unmatched finding is not always wrong, but a developer still has to read it.

One chip per finding on immich pull request 16893, repeat 1: Sol 17 findings with 0 matched, Neon 9 findings with 2 matched, Opus 8 findings with 0 matched
immich pull request 16893, repeat 1. One chip is one finding. A filled chip matched a human comment.

On one immich pull request, in repeat 1, Sol wrote 17 findings and matched none. Opus wrote 8 and matched none. Neon wrote 9 and matched 2.

immich pull request 16893: a human flags an unawaited preload promise on line 88. Opus wrote about it at line 60 and did not match. Sol and Neon both wrote about it at line 88. The judge matched Neon in 6 of 6 rounds and Sol in 0 of 6
Proof 07. The same immich pull request. The first row is the human reviewer's comment.

A human flagged a promise that nobody awaits, on line 88. Sol and Neon both put it on line 88 and said nearly the same thing. The judge matched Neon in all 6 rounds and Sol in none. That looks harsh on Sol to us.

Which model is fastest, and why is Neon slow?

Mean time for one planted review: Opus 65 seconds, Sol 127 seconds, Neon 148 seconds. Opus is about 2 times faster
Mean time for one review of a planted case, fastest first.

Opus reviewed a planted case in 65 seconds on average (median 62). Sol took 127 seconds (median 111) and Neon 148 (median 140). On real pull requests Opus took 117 seconds, Neon 264 and Sol 275. Against Opus, Sol was 1.94 times slower on planted cases and 2.35 times on real pull requests. Neon was 2.27 and 2.26 times slower.

Output tokens per planted review split into thinking and answer: Neon 25,655 with 75.1% thinking, Opus 10,230 with the split not reported, Sol 8,756 with 14.6% thinking
Output tokens per planted review, split into thinking and answer. Claude Code does not report Opus's thinking tokens apart.

Neon is not a slow writer. It produced 112.3 output tokens per second of model time, against 96.7 for Opus and 40.1 for Sol. It is slow because it writes about 2.5 times as many tokens as Opus per planted review: 25,655 against 10,230. 75.1% of them are thinking. For Sol the thinking share is 14.6%.

It is not the number of steps (10.7 model calls per review against 10.0 for Opus), and at least 99% of every review's time was the model, not the tools. Neon's typical call is as fast as Opus's, 8.2 seconds against 8.0 at the median. Its slow calls are much slower: the slowest 10% take over 52.9 seconds, against 20.7 for Opus.

How much does one AI code review cost with each model?

List price per planted review: Sol 0.29 dollars, Opus 0.52 dollars, Neon 0.57 dollars
List price per planted review, cheapest first.

The AI code review cost per review, at list price, was $0.29 with Sol, $0.52 with Opus and $0.57 with Neon on the planted set. For the whole test, both sets, the list price was $86.02 for Sol, $135.84 for Opus and $153.63 for Neon. The six scored runs came to $375.49.

List price per million tokens, read 21 Nov 2026InputCached inputOutput
Gemini 4 Neon$3$0.15$15
Claude Opus 5.5$4$0.20$20
GPT-6.2 Sol$2$0.10$10

Opus also charges $5 or $8 per million tokens for cache writes. Claude Code's own reported cost matched our list price calculation to the cent.

The Artificial Analysis chart suggested Neon for less money than Opus. On review at medium effort it went the other way: Neon's tokens are cheaper, but it writes about 2.5 times as many.

List price per matched human comment on real pull requests: Sol 0.98 dollars, Neon 1.47 dollars, Opus 1.77 dollars
List price for each real pull request finding that matched a human comment, cheapest first.

Per planted bug found, Sol cost $0.126, Opus $0.216 and Neon $0.236. Per matched human comment, Sol cost $0.98, Neon $1.47 and Opus $1.77. Neon costs more per review than Opus but less per match, because it matched more comments. Sol is the cheapest on every measure.

One pull request, ollama 9654, was about a quarter of every model's real pull request bill: 23.6% for Opus, 22.2% for Sol and 27.1% for Neon. No model matched any of its 3 human comments. Neon spent $17.93 on it, and 2 of its reviews there ended incomplete.

What a $200 plan buys

This section is our own measurement on our own subscriptions, not part of the benchmark report above. Plan limits change, so these numbers are from 22 November 2026.

API-price dollars of usage one month of each 200 dollar plan allows: Claude Max 20x about 4,560 dollars and 40 tasks per 1% of the weekly limit, ChatGPT Pro about 4,700 dollars and 155 tasks per 1%, Google AI Ultra 20x about 11,000 dollars and about 157 tasks per 1%, shown as an estimate
API-price dollars of usage that one month of each plan allows, on the same tasks. The black line marks the $200 price. Google's bar is an estimate, 4 times our measured $100 plan, drawn as an outline.

Each plan shows its usage as a percent of its limit. We ran the same tasks on each plan, priced them at API list prices, and divided by how far the percent moved.

  • Claude Max 20x ($200 a month). 1% of the weekly limit was worth $10.49 of API usage, about 40 tasks. That is about $4,560 of API-priced usage a month.
  • ChatGPT Pro ($200 a month). 1% of the weekly limit was worth $10.81, about 155 tasks. That is about $4,700 a month.
  • Google AI Ultra 20x ($200 a month), estimated. We could only measure the $100 plan. There, 38 tasks cost $6.17 at list price and moved the weekly percent from 33.86% to 34.83%, so 1% was worth $6.36. Our estimate for the $200 plan is 4 times that: about $11,000 a month and about 157 tasks per 1%.

Both measured plans give well over 20 times their price in API-priced usage. Limits still bite: Neon's quota ran out 25 minutes into its benchmark run, which then waited about 2 hours 40 minutes. The other two hit no limit.

Which is the best AI for code review?

ModelPick it whenWatch out for
Gemini 4 NeonA missed bug costs you the most. It found 102 of 102 planted-bug chances and 17.3% of human comments.Slowest on planted cases at 148 s a review, the highest price per review at $0.57, severity inflation, and a quota wall mid-run.
Claude Opus 5.5You run review in a fast pre-push loop. 65 s a review, and it left 4 of 4 clean changes alone.It matched the fewest human comments, 12.6%, and had the highest price per match, $1.77.
GPT-6.2 SolYou review at scale on a budget. $0.29 a review and $0.98 per match, the lowest on every cost measure.Noise: 8.49 findings per review, 87.3% matching no human comment, 2 false alarms on clean code and 5 missed planted-bug chances.

To catch the most bugs, pick Neon, which found the most in this test, give it a longer timeout and do not page on its critical label alone. For a fast pre-push loop, pick Opus: about twice as fast and quiet on clean code. For budget at scale, pick Sol and plan to filter its findings. If your question is Gemini 4 Neon vs GPT-6.2 Sol, the trade is clear: Neon finds more and less of what it writes is noise, while Sol costs about half as much per review.

There is no single best AI model for code review here. Pick the one whose weakness you can afford.

Limits of this test

  • Two repeats. Run-to-run spread beyond that is not measured.
  • One effort level. Medium only, and medium is each vendor's own setting.
  • Model plus pipeline. A bare model, or another pipeline, could rank differently.
  • Small planted cases. The planted repositories are small and written for the test.
  • Not held out. The real pull requests come from AACR-Bench's development split, not its held-out split.
  • One judge model. GPT-5.2 scored the real pull requests. It flipped on the same pair between rounds; averaging 3 rounds reduces that noise.
  • Scorer issues. Opus's single planted miss may be a scorer error, and the line rule can cost a correct finding its match, as on lvgl 8689. Nobody has ruled on 31, 37 and 89 open planted findings from Opus, Neon and Sol.
  • One expensive pull request. ollama 9654 is about a quarter of every model's real pull request bill, with no matches for anyone.
  • Unfinished reviews. On the real pull requests, 1 Opus review failed and 2 Neon reviews ended incomplete. Sol finished all 70.
  • Shared machine. Up to 15 reviews shared the Mac at times.
  • List prices. Every dollar is a list price, not a bill. A team with a paid API key would not see Neon's quota wait.

How Qodex uses this

We run this kind of benchmark to choose models for Qodex PR review. A model swap changes how many real bugs land on your pull request, how much noise comes with them and how long the check takes. So a new model goes through planted bugs and real pull requests before it reviews anyone's code.

The pipeline in this test is open source: OpenQodex runs on your machine before you push, on the coding agent you already sign in to. How Qodex reviews a pull request walks through every step, and our guides to Claude code review and Codex code review cover the vendors' own review tools.

To see what Qodex finds on your own code, connect a GitHub repository and Qodex reviews your newest open pull request.

Frequently Asked Questions

What is the best AI code reviewer in 2026?

No single model wins in our test. Gemini 4 Neon found the most bugs: 102 of 102 planted-bug chances and 17.3% of human review comments. Claude Opus 5.5 was about twice as fast, and GPT-6.2 Sol was the cheapest at $0.29 a review, with the most noise.

Is Gemini 4 Neon better than Claude Opus 5.5 at code review?

It found more: 102 of 102 planted-bug chances to Opus's 101, and 17.3% of human review comments to 12.6%. Opus was about 2.3 times faster and slightly cheaper per review.

Which model is the cheapest for AI code review?

GPT-6.2 Sol, on every measure: $0.29 per planted review and $0.98 per matched human comment at list price. The catch is noise: 87.3% of its real pull request findings matched no human comment.

Why is Gemini 4 Neon slower than Opus 5.5?

Neon writes about 2.5 times as many output tokens per review, and 75.1% of them are thinking. Its output speed is fine: 112.3 tokens per second against 96.7 for Opus.

How many false alarms did each model raise on clean code?

Opus and Neon raised none in 4 chances. Sol flagged a clean Python money formatter in both repeats, the only 2 findings ruled wrong on the planted set.

Were these models tested at maximum effort?

No. All three ran at medium effort, each vendor's own setting. Results at high or maximum effort could differ.

Does this benchmark measure the model or the tool?

Both. Every model ran inside OpenQodex with the same scanners, code graph and stages. Only the model and its command line tool changed.

Ship continuously. Test continuously.

Qodex explores your app, writes runnable tests, and replays them on every change at zero LLM cost.