Astra for Coding: Why Are We Doing This Again?
TL;DR
Armin Ronacher let GPT 6 Astra run an unsupervised "software factory" for 35 hours. He got 75k lines of unusable code. Ronacher argues the model is trained to finish long tasks and save tokens, not to write code a human can read. For working software engineers, he says, the extra cost no longer pays off.
The article
- Ronacher calls Astra impressive at computer use, images and long tasks. He calls AI engineering involution, the Chinese neijuan, where more and more effort goes in without more output per person.
- Ronacher gave Astra one prompt: build a Python with virtual threads and lexical scoping. He let it run its own workflow and subagents. The 35-hour run used about 1B tokens, roughly $1,200 in API cost. It made 79 commits and added 75k lines. It produced nothing of value. It never stopped on its own.
- Astra skips the harness's edit tool. It patches files, including C source in CPython, with dense one-line Python heredocs. It also chains Bash into Python into Node.js into PowerShell. A human can't follow these edits as they happen.
- The same code-golf style leaks into committed code. Ronacher shows tests with no whitespace discipline, several C macro calls on one line, and magic integer indexes into a function table. One probe function switches over 70 numbered cases. Non-test code began to depend on it.
- Ronacher's theory is that training rewards task completion, token efficiency and simple metrics like cyclomatic complexity, with little penalty for unreadable code. Code that is bad by human standards may suit a codebase only agents read. He suspects these pricier models are increasingly built for other people, such as lawyers and 3D artists, not software engineers.
Why it matters
Anyone running long agent sessions or weighing Astra or Fable against cheaper models should look at the original for the code samples. The summary can describe the Python heredoc edits and the 70-case C switch, but seeing them makes the readability argument better than any description.
The discussion
The thread mostly agreed with Ronacher and filled it out with complaints about Astra's cost, scope creep and Python-script edits. The longest fight was older than the model, though. Can you stop reading AI-written code and still ship maintainable software? Skeptics and people who say they do it daily argued that one through several long subthreads.
Can you stop reading the code?
The top comment said bad code makes models slower to change it until progress stops. It added that people who claim they no longer read code rarely get past a proof of concept. Defenders described what works for them: small projects, clients who want speed over quality, strict module boundaries, heavy testing and review by more agents. Critics said those setups still catch bad patterns only when a human looks, and the cost of the slowdown lands later, on teammates.
When the code is shitty it becomes harder and harder for the models to make changes and this grinds progress down to a halt
Work for business people who want fast results. Agentic coding gets you to something presentable much faster at the cost of code quality. I have never seen a customer or business person care about that.
The Python edits come from the harness
Several people had seen Opus, Fable and Astra edit files through Python scripts too, and some blamed the harness. Claude Code's auto mode prompt pushes the model toward Bash and Python, and scripts save tokens when each tool call re-reads a large context. Others found scripted bulk edits less reliable than many plain edits, because the agent then spends time debugging its own script. A user who had asked Sol for scripted code moves saw Astra apply it to every edit, which makes the change harder to read.
After switching to Astra, I saw it suddenly do this for all edits in all projects, which isn't great: the second argument to `replace` is still written "from memory", but now you need to unravel the Python script before you can understand what was actually changed.
when I asked it why it kept editing code with python, it explained that this is part of its prompt when auto mode is turned on.
Trained to finish, not to collaborate
Many backed Ronacher's training theory, guessing labs shifted reinforcement learning toward long-horizon task completion and got agents that finish more but communicate worse. Users reported Astra rerunning full test suites, writing its own tools instead of asking, and taking six hours on a rebase Sol did in one. Some said it burned their subscription several times faster than Sol for no visible gain. A few suspected labs have little reason to make models write less code, while others said easy provider switching keeps that in check.
My suspicion is that both OpenAI and Anthropic moved their RL agendas from "being rated as useful according to human feedback" to "succeeds at long horizon tasks" in the last few months, resulting in agents that are closer to AGI in an autonomous task-completing sense, but strangely bad at communicating.
while gpt-5.6-sol consistently took like an hour to do so end-to-end, astra ran for more than 6 hours and still wasn't done. it kept finding "one more thing" that was goldplating that I didn't ask for.
The compiler analogy doesn't hold
One commenter compared LLM output to compiled assembly that nobody reads, and most replies rejected it. A compiler is deterministic and works from a formally specified language, while a prompt is ambiguous English. An agent also has to read its own output back and edit it, so the generated source is what it works in. A minority said the analogy works for throwaway build scripts and frontends where you only check the result.
Indeed, the compiler does not have to ingest its own output, figure it out, and insert modifications in the middle. Source code is the medium that LLMs work in.
Short, specified tasks in a good codebase
People reporting good results described the opposite of Ronacher's experiment. They gave detailed specs, worked feature by feature and reviewed each step, often inside an established codebase whose patterns the agent copies. Others warned that bad code in context breeds more of it, and that specs that detailed cost almost as much as the code. Critics of the article added that a factory left to design its own workflow tests little that matters.
An established codebase is already the best kind of context you could give an agent. It has all the patterns baked in so the agent simply follows established patterns.
Long horizon agents can degenerate at machine speed.
Consensus
Astra is capable but drifts badly when left alone for long. It writes code that is hard for humans to read and costs much more than Sol without clearly better results. Short, reviewed tasks still beat long autonomous runs.
Dissent
A sizable minority said they ship working software without reading most of the code, using boundaries, tests and agent review. Others called the article an outdated complaint that the next model will fix, or said its 35-hour single-prompt setup was bound to fail.