
It has been a busy November for anyone who builds with AI models. Anthropic released Claude Fable 5.2 on November 9, the next step after Fable 5.1, which we reviewed in September. Eight days later, OpenAI followed with GPT-6.2 Astra, its flagship model, and GPT-6.2 Sol for everyday work, which we also reviewed.
That makes it an exciting time to be a developer. Three strong models arrived in just over a week, and each one handles the same work differently. In this review, we compare them side by side. First, as an example, we give two of them the same small game-development task and look at what each one builds and how it gets there. Then we compare all three using results from CodeRabbit’s internal code-review benchmark.
Figure 1. Two coding sessions on one time axis, started from the same one-line prompt at xhigh effort, one run each. Colour shows the phase our trace viewer assigned from observable activity; the area under each lane is context size. Helper agents are not included. Time spent does not show which result is better.
Seven minutes against two hours is a big gap. What stands out in the logs is how much longer Fable spent testing. It took about 17 minutes to make its first file change, then spent more than an hour, 62% of its active time, running and checking the game. Astra spent more than half of its active time changing files after a failed check. Fable’s context grew to about 800,000 tokens; Astra’s peaked at about 92,000. Here is what each built.
Jev, TypeSafe’s System One model, is playing both versions in the clip.
The graphics look comparable at a glance. Fable’s version also has a more extensive map and storyline, which this short clip does not show. Its extra testing time is the more interesting difference for a developer: when an agent runs for longer, look at whether it is checking behavior or repeatedly changing code after failures. These are single runs in different harnesses, both at xhigh effort, so they do not establish which model builds better games.
What the code-review benchmark shows
For code review, we use CodeRabbit’s internal benchmark. Our code-review harness normally combines several models. In these evaluations, we substitute the model under test into parts of that ensemble and measure the reviews it produces.*
The benchmark results show different strengths: Fable caught the most known issues, Sol at low reasoning produced the fewest nitpicks, and Astra generated the most comments. An extra finding can help you fix a bug, but every extra comment also needs someone to read it.
Figure 2. Separate evaluations with different setups and issue totals, not a controlled ranking. Fable’s range spans six runs, not a confidence interval. See methodology notes below.
Fable caught the most known issues
| Measure | Fable 5.2 | GPT-6.2 Astra | GPT-6.2 Sol, low reasoning | GPT-6.2 Sol, high reasoning |
| Known issues caught | 63–66 of 81 | 58 of 83 | 59 of 81 | 60 of 81 |
| Coverage | 77.8–81.5% | 69.9% | 72.8% | 74.1% |
| Benchmark precision | 30.5–36.0% | 12.22% | 32.7% | 25.9% |
| Nitpicks per run | 40–64 | 215 nitpick/assertive | 11 | 33 |
Astra’s and Sol’s figures come from our GPT-6.2 Astra and Sol review.
Fable’s weakest run caught 63 known issues. Sol’s best caught 60, and Astra’s caught 58 of a slightly larger set. That is the strongest reason in these results to give Fable another look.
Fable’s result did move when the test set changed. On a separate 85-issue set it caught 49 to 54 known issues, or 57.6% to 63.5%. We have not run Astra or Sol on that set, so we cannot say whether they would drop in the same way.
Figure 3. Observed ranges across separate evaluations. Astra and Sol were not run on the 85-issue set.
For a developer, the useful inference is narrower than “switch everything to Fable.” It looks worth testing as another review pass on changes where you particularly want to avoid missing a bug. Start with pull requests that contain problems you already understand. Check whether it finds something useful that your current setup misses, and whether it holds across more than one kind of change.
The review has a reading cost
Coverage is half of a review. The other half is what you have to read to get it.
Nitpicks do not contribute to the coverage score, but they still turn up in someone’s review. They have a talent for making a small PR feel surprisingly large. Sol produced 11 at low reasoning and 33 at high. Fable produced 40 to 64 per run. Astra produced 215 nitpick or assertive comments.
Figure 4. Minor and major counts include summary-section findings. Major includes critical; nitpicks include assertive comments. Outside-diff comments are excluded. Fable and Sol used 81 issues; Astra used 83. Setups differ.
We also measure benchmark precision: the share of regular actionable comments that match known issues. Fable ranged from 30.5% to 36.0%, close to Sol at low reasoning (32.7%) and above Sol at high reasoning (25.9%). Astra’s was 12.22%: it wrote 589 regular actionable comments, and 72 of them matched a known issue. That does not mean the remaining comments were wrong. They may describe real problems outside the benchmark’s labels. Someone still has to read them to find out.
Figure 5. Normalized to 100 regular actionable comments. Partial squares preserve exact percentages; the lighter Fable fill shows its observed range. Unmatched comments may still be valid. Setups differ, including pipeline placement between Sol runs; these values do not establish a model ranking or isolate reasoning effort.
Put together, the three models make different trades. Sol at low reasoning is the quiet one: the fewest nitpicks, precision in Fable’s range, and lower coverage. Fable finds more known issues at similar precision and brings more nitpicks than either Sol run. Astra’s catches come with the most reading of the three.
That is why “more bugs found” and “better review” are related, but separate, questions. An additional finding earns its place when it helps you make a useful change. A plausible warning that takes ten minutes to disprove has a cost too, even if token generation is cheap.
When asking a coding agent for a second review, a concrete prompt is more useful than simply asking it to be thorough. For example:
Review this diff and its callers for behavior changes. For each issue, explain what triggers it, what the user would observe, and how I can verify it. Separate optional cleanup from bugs. If you are uncertain, say what evidence is missing.
A small gain can mean much more to read
Sol’s high-reasoning run produced 290 regular actionable comments, compared with 202 at low reasoning. The number of known issues caught increased from 59 to 60. That is 88 more comments to read for a net gain of one known issue. The setups also differed, so this is not a clean test of reasoning effort.
For your own codebase, compare what each review catches and misses, then decide whether the extra findings justify the reading time. We have not yet compared all three models issue by issue, so these results cannot identify which one catches bugs the others miss.
For coding, effort changes the decision
The benchmark results above measure review output. For code-writing context, Bito tested two multi-step coding tasks, with four sessions per task and configuration. OpenAI models ran in Codex; Fable ran in Claude Code at medium effort. This is a small, separate evaluation.
Sol’s hard-session score rose from 67.3% at low effort to 75.8% at high. Cost rose from $1.22 to $2.22, and time from 12.2 to 29.5 minutes. At high effort, Astra scored 76.9% for $8.19; Fable at medium scored 81.0% for $8.13. Those are session costs at list prices.
Figure 6. Independent coding results from Bito, November 18, 2026, not CodeRabbit review results. Two hard tasks, four sessions each, at list prices. Astra and Sol ran in Codex at low and high effort; Fable ran in Claude Code at medium.
Fable was only tested at one setting, and that matters. Anthropic’s system card reports that its FrontierCode 2.0 score rose from 37.6% at medium effort to 45.3% at high, while the cost per task rose from $2.48 to $6.72. A medium-only run shows neither Fable’s ceiling nor its bill at higher settings.
Our inference: try the effort setting before assuming you need a more expensive model. Sol’s high-effort result makes it an interesting candidate for a longer task you can leave running. The extra wait would be much less welcome when you are asking a quick question and trying to stay in the flow.
What we’d try on the next pull request
- Everyday coding: Give two models the same task and tests. Compare the corrections, failed checks, and time to a reviewable change, alongside the bill.
- A task that keeps getting stuck: Try more effort or another model with the same failing test. Ask it to reconsider the explanation before writing another patch.
- Code review: Reuse past PRs with known bugs. Check what each model catches and misses, and how much feedback you have to read.
Fable’s coverage and Sol’s lighter reading burden make both worth testing. Keep the model that leaves you with better code and less unresolved work.
Methodology notes
The review benchmark scores final comments after verification and filtering. A known issue counts as caught when a regular actionable comment matches it. Nitpicks, outside-diff comments, and findings confined to summaries do not count toward coverage. Benchmark precision measures matches to known issues; an unmatched comment is not necessarily wrong.
These were separate evaluations: Fable ran six times against 81 known issues, Sol once per reasoning level against 81, and Astra once against 83. The parts of the model ensemble replaced also differed, including between Sol’s two runs. The results do not isolate model choice or reasoning effort. Fable’s ranges describe observed runs, not confidence intervals. The workflow suggestions in this article are our interpretation, not measured productivity gains.



