GPT-6.2 Astra Coding Reviews: Why Some Testers Still Prefer Claude
What early GPT-6.2 Astra coding reviews actually show, how Claude comparisons differ, and when to intervene in a stalled agent run.

Early GPT-6.2 Astra coding reviews give a practical reason to keep Claude available: several testers describe an agent that can produce good work but needs too much help to finish extended jobs. They report stalled runs, premature handoffs and work that another agent replaced. Those reports support caution about unattended builds; they do not establish a universal Claude victory.
The important distinction is which job you want to delegate. Reviewing a patch, solving a single-file problem and owning a feature through integration demand different evidence. Developers Codex has not run a comparative benchmark. This assessment separates the testers' accounts from measured results, then shows how a maintainer can respond to the reported failures.
What the early Astra coding reviews actually report
These November 17 accounts describe different workflows and different Claude comparators. Read the limitation beside each claim before treating it as a buying decision.
| Firsthand source | What the tester reported | What the account establishes |
|---|---|---|
| Theo's testing letter | A game-level run paused over another agent's internal filename. His compiler project slowed down instead of improving. He preferred Opus 5.5. | Specific examples of supervision and goal drift in his setup; no independently replicated failure rate. |
| Dan Shipper, Every | Similar performance to Astra 6 on most team benchmarks, but frequent early stops on end-to-end builds. His overall comparison favored Fable 5.2. | A team's prerelease impression; the post does not provide a shared task set, traces or a numerical coding comparison with Fable. |
| Matt Shumer's follow-up | Fable 5.2 and Opus 5.5 agents redid work assigned to Astra as a subagent. | Rework in his delegated workflow; the post does not establish why each replacement was necessary. |
Theo's most concrete example is ts-rust, a TypeScript compiler rewrite in Rust. He says Astra spent seven days seeking improvements but made the compiler 56% slower. After a performance-focused redirection, it ran four more days without changes. That is his account, without our independent replication. He also credits Astra's review, code quality and 3D work, and says OpenAI fixed some complaints. The same letter contains both assessments.
Shipper says Every tested Astra 6.2 and Sol 6.2 for several weeks. The team's testing page now links to its November 17 Vibe Check. Most of that article is subscriber-only, so we retain the narrower coding claims from his accessible launch post. That post cannot supply a measured advantage for Fable.
Shumer's initial post broadly rejects both new models. The subagent detail is more useful than the verdict: it identifies a handoff worth examining. Without the delegated instructions, patch and acceptance checks, another agent's decision to redo work cannot substitute for a maintainer's verdict.
GPT-6.2 Astra vs Claude: what the benchmarks can answer
There is no single coding score that resolves those complaints. A benchmark's task shape and agent software determine what its result can tell you.
In its November 17 launch analysis, Artificial Analysis reported no improvement over GPT-6 Astra on its Coding Agent Index, using Codex at Max effort. This compares complete agents, including their tools and instructions. The current index methodology, version 2.1, combines repository changes, terminal tasks and repository questions. Benchmark versions and grading can change; preserve the dated result rather than treating it as a permanent rating.
On the separate FrontierCode-AA 2.0 evaluation, checked November 18, Fable at High with default fallback scored 49.1% and Astra at Xhigh scored 49.0%. Artificial Analysis uses its shared Stirrup agent software and averages three attempts on each of 132 repository tasks. These are mean rubric scores, not the percentage of tasks completely solved: failing a blocking check earns zero. Different effort settings and Fable's fallback option still matter. That tenth of a point provides little basis for choosing a default by itself.
FrontierCode also illustrates what "finished" means. Its published Mock Service Worker example requires restarting a generator after a reset and closing the discarded generator so its cleanup runs. A patch can fix the visible symptom and still fail the task. That is a concrete reason to inspect preserved behavior rather than accept a plausible diff. The example is the evaluator's, not a bug Developers Codex tested.
Another firsthand evaluation, CodeRouter's 175-task Python test, reported Astra solving 97.1% with one retry, versus 100% for Opus 5.5 and Sonnet 5.5. These were single-file exercises: instructions and a stub went in, a complete file came out, and failing tests allowed one retry. Fable was not in that table.
CodeRouter sells a routing product and discloses its method's limits: public tasks, one run per model, default reasoning effort and different testing dates and call paths. It expressly says long agent sessions with tools were untested. Its results help answer a bounded code-generation question. They cannot establish how well Astra manages a week-long repository task.
OpenAI's launch announcement says early testers saw cleaner coding style, focused tests and fewer revision rounds. The critical accounts show why a launch claim needs a task-level check. A reviewer can like the code and still reject the workflow that produced it.
There is positive evidence for another task shape: our analysis of Astra's AA-3D lead explains its result in human comparisons of interactive browser scenes and offers a Three.js trial brief. Preference for a finished scene does not resolve the reports of stalled repository work here. If your job is a visual prototype, test that deliverable directly; if it is an integrated feature, require evidence that the agent finished the integration.
Three failures that require different interventions
Our assessment is that the early complaints concern three separate boundaries: maintaining the objective, deciding when to stop and passing work between agents. Adding one generic "keep going" instruction cannot tell you which boundary failed.
Goal drift: A compiler task can improve binary size while damaging execution speed. Write down which metric is the objective and which metrics are constraints. When a checkpoint misses a constraint, preserve the measurements and return to the last acceptable revision before authorizing more optimization. Otherwise, further work starts from a regression you never agreed to accept.
Premature completion: For an end-to-end feature, distinguish code written from behavior integrated. An endpoint might exist while its caller, validation or failure state remains missing. Ask the agent to map each acceptance criterion to the implementation and a verification result. An honest list of unfinished items is useful, but it still means the build is unfinished.
Broken delegation: If a supervising agent rejects a subagent's patch, retain the original work and require a specific reason. A failed test, interface mismatch or incorrect assumption makes rework assessable. "The other model rewrote it" establishes effort spent, without establishing that the rewrite was better. For internal-file questions, first determine whether the supervising agent can inspect the relevant artifact itself; only a genuinely missing decision should require the user's attention.
These interventions are proposed review practices, not fixes we have demonstrated for Astra. They make the next attempt diagnosable. That matters even if you ultimately switch providers: a team should know whether it is escaping a model limitation, an incomplete handoff or an ambiguous task.
What to do when an Astra run stalls
Set a checkpoint before leaving a long job unattended. Base it on observable evidence appropriate to the task: a regression reproduced, one candidate measured, or the requested integration running. If the agent reaches the checkpoint without new evidence, pause and inspect the run before extending it.
For a hypothetical compiler optimization, a maintainer could give this acceptance contract:
Reduce median compile time by at least 5% on our fixed fixture suite. Preserve output correctness and keep peak memory within 5% of baseline. Use the same machine, command and fixtures before and after each candidate. After three candidates without a qualifying improvement, report the measurements and stop for review. Do not change the grading fixtures or trade speed for binary size.
Those percentages and the three-candidate limit are illustrative choices, not benchmark findings or universal thresholds. The project owner should choose tolerances that exceed ordinary measurement noise and fit the actual requirement.
Suppose the first candidate is smaller but slower. The useful intervention is specific: "This misses the compile-time objective. Preserve the measurement, restore the last passing revision, and explain what evidence supports your next candidate before continuing." That gives the agent a review decision it can act on. Simply asking it to work harder leaves the failed priority unresolved.
When the run ends, ask for the revision tested, the exact checks and their outcomes, any remaining criterion, and the next decision needed from a human. Count a patch requiring central behavior to be rewritten as rework. Include the original attempt when comparing time and cost with Claude.
A checkpoint prompt you can reuse
Paste this at an agreed checkpoint or when progress becomes unclear. Use the report to compare the agent's account with the actual patch and tool log.
Report the current state of this task against our acceptance criteria.
1. Objective and constraints: restate the agreed goal and limits.
2. Revision: identify the commit or working-tree changes being assessed.
3. New evidence: state what changed since the last checkpoint.
4. Checks: list exact commands actually run and their outcomes.
Separate failed checks, checks not run, and assumptions.
5. Remaining work: map each unmet criterion to the missing behavior.
6. Blocker or stopping reason: name it explicitly. If a human decision
is needed, state the specific decision and why available tools or
repository evidence cannot resolve it.
Do not call the task complete while a required criterion is unmet.
Do not report a check as passing unless its result supports that claim.Check the reported revision and results before deciding whether to let the run continue.
For a broader side-by-side rollout, use our GPT-6.2 developer testing guide. Keep the repository state, permissions and acceptance conditions equivalent, and record the exact Claude version. Theo's Opus preference and Every's Fable comparison answer different questions.
Astra's case for code review can survive criticism of its unattended builds. Give it the role its verified work earns in your repository. Move ownership of longer jobs only when the accepted result and the review burden justify it.
Updated November 18: Rechecked the original tester posts and coding evaluations, replaced mirrored citations with original sources, clarified FrontierCode's scoring method, and added Every's published follow-up. The tester results remain their reported observations; Developers Codex has not independently replicated their runs.

