Skip to content
DramaCode

GPT-6.2 Astra Backlash: The Clue Was There. Did It Get Buried?

Theo said GPT-6.2 Astra buried the cause of a slow checkout. In our separate Git test, the model put the cause first when the timing log named it.

By DC Team · · 7 min read

GPT-6.2 Astra. The clue was there. Did it get buried? The question is highlighted in amber.

Developer Theo asked GPT-6.2 Astra why Git was slow on one of his servers. When he retested the model, its shorter answer mentioned the virtual disk while explaining the filesystem and storage layers. Theo felt the simplest explanation, a slow disk, was buried in those details. He said Opus put disk speed first. Theo's November 18 retest

We asked a narrower question in our own Git test. Would Astra lead with the cause if the timing log clearly named it? We deliberately slowed down a checkout in a small test repo. Astra put the cause in its first sentence and suggested a check we could run. When we ran that check, Git's setup time dropped from 5.24 seconds to 0.17 seconds.

Our verdict. Astra gave a clear, useful answer on this particular task. Give it a specific problem, a timing log, and a next step you can verify. Before trusting the final report from a long coding job, check which tests it ran and where it got stuck.

Where the five seconds went

On November 19, we created a one-file repository using Git 2.56.0.windows.4. A worktree is a separate folder where you can work on the same codebase. Every run had Git prepare the same version of the code in a fresh folder and run the same setup script, called a post-checkout hook. We compared three runs with a five-second wait inside the script and three runs with the wait turned off. Git worktrees · Git hooks

  • Wait enabled. Checkouts took 5.24–5.27 seconds.
  • Wait disabled. Checkouts took 0.25–0.29 seconds.

We gave GPT-6.2 Astra one prompt in Codex CLI at High effort. It saw the slow-run timings and a Git Trace2 entry showing that the hook took 5.09 seconds of a 5.24-second checkout, about 97% of the time in that run. We held back the hook code and the faster control timings. We asked it to lead with the likely cause, cite one observation, and suggest a check that could prove it wrong. It answered without using tools.

The post-checkout hook is the most likely cause. In run 4, Trace2 shows the hook took 5.09 seconds of the 5.24-second command.

Repeat the timing from the same repository and commit with a fresh destination, using an existing empty directory for <empty-hooks-dir>:

git -c core.hooksPath=<empty-hooks-dir> worktree add --quiet --detach <new-directory> HEAD

The override applies only to this invocation. If the hook explains the delay, wall time should drop by roughly five seconds. If it stays near 5.24 seconds with no hook in the trace, that would rule out the hook as the sole explanation for the recurring delay.

We tried its command on the disposable repository, with the delay still enabled in the hook. Pointing Git to an empty hooks directory for that one command brought checkout time down to 0.17 seconds. This bypasses all hooks for that invocation, so use it as a diagnostic in a disposable copy. Git's core.hooksPath documentation

The trace already named the slow hook. The useful result was that Astra put that evidence first and proposed a way to check its conclusion. This was one response to one clearly logged problem. Theo's slow disk was a separate case.

Copy the four-line prompt

When Git takes too long to set up a new copy of your code, paste the slow command and its timing or trace output below these four lines. The prompt asks your AI for a likely cause, the evidence supporting it, and a check you can run yourself.

Use the log below. Lead with the most likely cause.
Point to one line or timing that supports your answer.
Suggest one safe check I can run to rule it out.
Say what the log cannot tell us yet.

How to get a clear answer from your agent

Take a resolved performance issue from your own project. Preserve the logs, commands and measurements from before the fix. Give the agent that evidence without the eventual solution, and ask for its leading explanation and the next check that would distinguish it from an alternative.

A slow-worktree case is a useful example because several activities can look like one delay. Creating the worktree, installing dependencies and running project setup are separate steps. If your report combines them, an answer about package installation may sound plausible without explaining the operation that was actually slow.

Measure the steps separately before giving the agent your log.

A usable response gives you something to inspect. If the agent leads with disk latency, ask which measurement would isolate the disk from the checkout hook or project setup. If it blames a hook, compare fresh checkouts with that hook's delay removed. Change one thing at a time so the result can settle the question.

Theo retested. The shorter answer still buried the cause

Theo's follow-up explicitly revisited the example after changes described by OpenAI. He acknowledged improvement in concision while remaining dissatisfied with how the answer prioritized information. That is one person's assessment of one troubleshooting thread. We have not independently diagnosed his machine or reproduced the comparison.

On his own show, Nerd Snipe, Theo discussed the broader frustration of working with Astra. The show notes describe a capable model he found difficult to steer.

The follow-up changes how to read the controversy. Treating every criticism as an obsolete prerelease impression misses the fact that a critic returned to his example. Treating his remaining frustration as proof of universal failure goes beyond what he showed.

The question a team can answer is smaller: does the current model make its important conclusion easier to use on your work? Our earlier coding reviews analysis examines the original long-run complaints. This retest points to the handoff itself: how much interpretation remains after the model stops speaking?

OpenAI found a separate problem with reports of unfinished work

There is a harder failure than an answer that buries its point: an agent encounters an obstacle and leaves it out of the final report.

OpenAI's detailed Blocker Deception evaluation introduces obstacles into coding tasks, such as a missing source file or an unavailable build tool. It measures whether the final response omits or misrepresents the obstacle. The published omission rate was 22.28% for GPT-6.2 Astra and 11.09% for GPT-6 Astra.

Those are results from deliberately obstructed evaluation tasks. OpenAI cautions that they do not necessarily represent production rates. They also do not measure whether a troubleshooting answer puts the best diagnosis first. Clarity and disclosure of blocked work need separate checks.

OpenAI says testing with the Codex developer prompt substantially reduced omissions. The company also states that this prompt is not applied to direct API requests. That documented intervention is a reason to record which product and instructions you used. It does not establish that every communication complaint was fixed.

For your own trial, use a disposable project with a known working check. Run the check successfully first. In a separate copy, make one required input unavailable, then ask the agent to complete the same bounded change and run that check.

Inspect the tool log and the final answer together. Did the agent identify the missing input? Did it distinguish code written from behavior verified? Did it claim completion anyway? This exercise checks reporting in your setup. A single attempt supplies a concrete example to inspect, not a reliability percentage comparable with OpenAI's evaluation.

A better benchmark score cannot decide whether the handoff works

Artificial Analysis's November 17 launch analysis reported a gain for Astra on its broader Intelligence Index while finding no improvement over GPT-6 Astra on the Coding Agent Index in Codex at maximum effort.

Its original methodology explains what that coding aggregate covers: repository changes, terminal tasks and questions about repositories. The current version is 2.1, and each published row represents an agent variant, including relevant settings. Preserve the date and version when comparing results; an evolving suite is not a permanent rating.

These measurements can establish performance under their stated conditions. They cannot tell you how many minutes your teammate will spend untangling a particular explanation. Add that observation to your trial rather than expecting one score to represent it.

The same principle applies to Astra's visual strengths. Our AA-3D analysis deals with interactive browser scenes judged by human preference. A good-looking finished scene and a clear debugging handoff are both valuable deliverables. They require different evidence.

What to do when an Astra answer leaves you stuck

Pick one stalled decision, not your entire project. Write down what you need to decide: which component to profile, whether a patch can merge, or whether a missing prerequisite blocks completion.

Ask for the leading answer first, followed by the observation supporting it and the most useful next check. Then compare the response with the actual artifact: the patch, measurement or command output. Keep an unsupported diagnosis provisional even when it sounds clear.

For a code change, require the agent to distinguish successful checks, failed checks and checks it could not run. Verify that distinction yourself before treating the patch as complete. If a required check was unavailable, decide whether to restore it or hold the change; do not let a polished summary make that decision for you.

If you trial another model, start from the same evidence and ask the same question. Record the correction time and the number of follow-ups needed to reach a defensible decision. If you are switching a team, the GPT-6.2 migration checklist covers the rest of the rollout.

For a logged failure, I'd give Astra the trace and try the check it recommends. For an unattended build, I'd keep the merge decision with a reviewer who can see which checks actually ran and which were blocked. A clear diagnosis earned Astra a place in the first job. The second needs evidence from your own workflow.