Entelligence Benchmarks GPT-5.6 Luna Against GPT-6 Astra for Code Review

Entelligence has published a direct comparison of two OpenAI models on code-review work, setting GPT-5.6 Luna, priced at roughly $1.20 per unit of work, against the newer and larger GPT-6 Astra. The company framed the test around a purchasing question rather than a capability demo: can the cheap model catch enough real defects that a team would ship its output? The write-up is live at entelligence.ai, and the accompanying Hacker News thread (item 49703003) has turned into a long argument about where the acceptable cutoff sits.

The comparison deliberately targets review rather than generation. Reviewing a pull request rewards different model behavior than writing code from a blank file: it means spotting subtle regressions, flagging security problems, and explaining a fix in terms a developer can act on without re-deriving the whole change. Entelligence's angle is practical. A model that finds most genuine bugs at a fraction of the price is a different procurement decision than a premium model that finds somewhat more, particularly for teams that run an automated pass on every pull request.

That per-call arithmetic is the reason the piece got traction. Coding agents and review bots are now standard fixtures in many engineering pipelines, and routing review through API calls turns model choice into a recurring line item rather than a one-time license. When the delta between a budget tier and a flagship is measured per invocation, the question stops being which model is smarter and starts being which model is smart enough for this specific job.

The thread shows readers are split, and not only on the verdict. Some want raw benchmark figures and a clear scoring method; others want to know how each model performs against their own repository, where style, language mix and test coverage change what counts as a good catch. Entelligence's post supplies one data point, and the disagreement in the comments is less about the result than about what a single benchmark can prove.

What the comparison does not settle is how to measure review quality at all. Bug-catch rate is the obvious metric, but false-positive noise matters just as much, because a reviewer that flags non-issues burns developer time. Latency and the cost of a human re-checking the model's output both feed into the same calculation, and different teams weight those factors differently depending on how expensive a missed defect is for them.

The open question is whether cheaper models have narrowed the gap enough that a premium review pass becomes optional rather than default. The answer probably depends on codebase complexity and the blast radius of a bug that slips through, which means the same benchmark can justify opposite decisions at two companies. Expect more cost-per-task comparisons like this one as model pricing spreads out across tiers and vendors compete on price rather than raw scores.