A developer who has worked on the CPython interpreter left an autonomous coding setup running on GPT 6 Astra for 35 hours and came back to 75,000 new lines of code across 79 commits. His verdict on all of it was blunt: nothing of value.
Armin Ronacher published the run on 7 September, and it has been near the top of Hacker News since. The number that matters for anyone budgeting AI work is not the line count. It is the bill.
What the experiment actually was
Ronacher calls the setup a software factory: an agent left to work on its own, without a human reviewing each step. He ran it against real code rather than a toy problem, and he let it run to the end rather than stopping at the first strange output.
The framing he reaches for is Neijuan, the Chinese term for involution, where more and more effort produces no more output. That is the claim worth testing, because it is about return rather than capability.
Where the money went
The run consumed roughly one billion tokens. At the rates he quotes that came to about $1,673, which works out near $22 for each of the 79 commits. Those are Australian figures: OpenAI bills in US dollars, so the local cost moves with the exchange rate, and this conversion uses the Reserve Bank rate for 11 September.
Put next to a developer’s hourly cost, $1,673 for a day and a half is not absurd on its own. The problem is the denominator. A day and a half of a junior developer produces something you can review, revert and learn from. Here the output was discarded.
The comparison that matters is not against a salary, it is against the same model supervised. Run with a person reviewing each change, the token spend is a fraction of this because the work stops when it goes wrong. Left alone, a wrong turn in hour three is still being elaborated in hour thirty.
It is worth holding this against the other direction of evidence. We covered four Codex agents clearing years of technical debt at Asana, which is the same pattern of unattended agents producing a very different result. The difference is not the idea. It is the setup and the supervision.

The part that reaches your codebase
This is the finding with teeth. Astra compresses the code it writes for its own tool calls, stripping whitespace and reaching for string manipulation instead of proper edit tools. Ronacher found that compression bleeding into committed work, including unit tests, where it is close to unreadable.
In his words, the model is trained for token efficiency when calling tools, that output also looks like code, and it sometimes carries the style into places it should not. The examples are specific: Python doing string surgery on C files, Python invoking Node to run PowerShell, hardcoded constants and magic numbers left in production, and C macros that break the conventions of the project around them.
None of that shows up in a benchmark score. It shows up six months later, when somebody has to read the thing.
Why Australian businesses should pay attention
Unattended agents are being sold locally as a way to get more engineering out of the same headcount. This run is a reminder that the ceiling on that is not the model’s intelligence, it is how much unreviewed output a team can absorb before it becomes a liability.
The practical control is boring and it works: cap the spend per run, require a human to review before anything merges, and count cost per merged change rather than per token. Australian firms were already already tightening AI budgets as costs outran forecasts, and an agent that can spend $1,673 without asking is exactly the shape of the problem.
For teams weighing which assistant to standardise on, our comparison of Claude Code and Codex covers the supervised end of this, where the human stays in the loop and the bill stays legible.
There is a governance question underneath the budget one. An agent that can open a terminal, install packages and commit for 35 hours is a user account with unusual reach, and most Australian teams have not written down what it is allowed to touch. That policy costs nothing to draft and is far cheaper than discovering the answer from a commit log.
What Ronacher does not say
He does not say Astra is unusable, or unintelligent, or that he is done with AI models. He rates it highly for 3D graphics, mathematics and legal work, and his complaint is narrow: for present day software engineering, the return is poor compared with the models he was using before.
He names Sol and Fable as the ones that did not behave this way, while acknowledging that Fable is expensive. That is a real trade off rather than a verdict, and it is the trade off a buyer has to make.
A cost question, not a capability one
The interesting shift in this piece is that the argument has moved. A year ago the question was whether these models could write useful code at all. Now a developer of Ronacher’s standing takes the capability for granted and argues about whether the trajectory suits how software actually gets built.
His own summary is that he is increasingly sceptical the current direction fits present day engineering processes. That is not a prediction about the technology. It is a statement about process, and process is the part a business can change.
For anyone setting an AI strategy for the next quarter, the useful takeaway is to stop buying capability and start buying reviewed output. They are not the same product.
