Flask's Creator Burned $1,200 on an AI Coding Run and Three Communities Spent the Week Agreeing With Him
Armin Ronacher spent $1,200 and 35 hours on a GPT-6 Astra experiment that produced 75,000 lines of code he called worthless. A researcher measured AI code as twice as verbose as human code. Hacker News hit 746 points asking to limit AI news. The backlash has numbers now.
The WJS Desk
Sep 12, 2026 · updated 12 days ago · 6 min read
Three things landed in the same week of September 2026, and together they mark a shift. Armin Ronacher, the creator of Flask, Jinja2, and a core contributor to Ruff, published a detailed breakdown of a 35-hour GPT-6 Astra experiment that burned $1,200 in tokens and produced 75,000 lines he judged worthless. A researcher at Earendil published formal metrics showing AI-generated code is roughly twice as verbose and twice as eroded as human-written code. And Hacker News hit 746 points on an Ask HN post titled "Can we please limit the AI news flood?" with 361 comments.
The AI coding backlash is not new. What is new is that it has measurements, cost breakdowns, and a respected maintainer's name attached to a per-commit price tag of $15.50.
The experiment: $1,200 for 79 commits
Ronacher's post, titled "Astra for Coding: Why Are We Doing This Again?," is the centrepiece. He describes GPT-6 Astra as "an incredibly impressive model" that excels at computer use and image understanding, and then methodically documents what happened when he let it run unattended for 35 hours on a real codebase.
The results, as Ronacher reports them: 4 billion tokens consumed (approximately $1,200 at raw pricing), 79 commits, 75,000 net lines of code added, and output that he judged delivered "absolutely nothing of value." The per-commit cost: roughly $15.50.
The specific failures he documents are more instructive than the headline number. Astra abandoned its available editing tools in favour of raw Python scripts for file manipulation, writing code-golfed single-line solutions to string operations. It produced hardcoded random constants in production code and used random array indexes for state management. Its unit tests, which Ronacher separately called "absolutely horrific" on X, degraded over time from descriptive naming to sequential numbering ("1, 2, 3") and eventually to what appear to be hash fragments ("8b2c2b3").
"I do not feel like the results are there."
Armin Ronacher (@mitsuhiko), September 7, 2026
His framing is worth quoting because it is not anti-AI: he explicitly praises the model's capabilities and says earlier models like Fable did not exhibit the same aggressive autonomous behaviour. His argument is that Astra's relentless task completion instinct is a regression for software engineering, not an advance.
The measurement: 2x more verbose, 2x more eroded
The same week, Sebastian at Earendil published "Measuring the sloppiness of code," which introduces two formal metrics from the SlopCodeBench research: verbosity (duplicate and unnecessary lines measured via AST-Grep and clone detection) and erosion (the proportion of code mass concentrated in functions with cyclomatic complexity above 10).
The results compare AI-generated code against established repository code:
| Metric | Human code | AI-generated code |
|---|---|---|
| Verbosity | 0.15 (SD 0.06) | 0.33 (SD 0.10) |
| Erosion | 0.31 (SD 0.17) | 0.68 (SD 0.20) |
AI-generated code is approximately twice as verbose and twice as eroded as human-written code, per these measurements. The post acknowledges the metrics are imperfect. Verbosity can be gamed (Goodhart's Law applies), and lines of code changes are "a surprisingly effective simplicity metric" but not a complete one. The author's conclusion: evaluating code quality "fundamentally requires human intuition and taste" because formal correctness does not capture design quality.
The reaction across platforms
Ronacher's post pulled 425 points and 314 comments on Hacker News. The Earendil piece got 242 points and 222 comments. The Ask HN post about limiting AI content hit 746 points. Combined: over 1,400 points and nearly 900 comments in a single week, all touching the same nerve.
The Hacker News thread on Ronacher's post produced the sharpest exchanges. taurath, in the top-voted comment, argued that AI-generated code "becomes harder and harder for the models to make changes" as complexity grows, and that teams using agentic coding without oversight experience severe slowdowns. codingisfreedom reported that Astra consumed 100,000 tokens on documentation and reviews instead of implementation over two days of MVP work, concluding: "I'm pretty sure an average senior engineer would have finished much quicker."
The dissenting view came from xgb84j, who argued that agentic coding "gets you to something presentable much faster at the cost of code quality" and that for projects under 500,000 lines with clear API boundaries, the tradeoff works if business stakeholders prioritise speed. matheusmoreira went further, arguing that AI-generated code is analogous to compiler output: disposable and irrelevant, something developers should not review any more than they review machine code.
The most structurally interesting comment came from nchie, who suggested the solution is modularity: review module boundaries rather than line-by-line code, and contain damage from poor implementations by ensuring "if something ends up wrong, it's going to be isolated and it doesn't infect the rest."
The academic backing
Running underneath all three threads is an academic paper from earlier this year, "An Endless Stream of AI Slop," which analysed 1,154 posts across Reddit and Hacker News about the burden of AI-assisted development. The paper identifies three categories of concern: review friction (AI output burdens reviewers and erodes trust), quality degradation (damage to codebases and developer competence), and systemic consequences (individual productivity gains externalising costs onto reviewers and maintainers).
The paper frames AI code quality as a tragedy of the commons. Individual developers ship faster. Reviewers, maintainers, and the broader community absorb the cost. That framing showed up independently in multiple HN comments this week without anyone citing the paper, which suggests it accurately describes something developers are experiencing firsthand.
What the platforms disagreed about
Hacker News argued about whether the problem is solvable with better workflows (ports/adapters, domain-driven design, comprehensive testing) or fundamental to the technology. The thread on limiting AI news revealed a different fault line entirely: smt88 wrote about being a "hacker since I was 10" who changed their mind after seriously using Claude Code with Opus 4.5, while iLoveOncall argued that HN has been "heavily astroturfed" by AI labs for over a year. andyjohnson0 counted the front page and reported that 21 of 30 stories were not AI-related, pushing back on the "flood" framing with data.
On X, Ronacher's tweets were more pointed than his blog post. He specifically called out Astra's Python code as "weird Python slop" when the model was "one step removed from normal code" and its unit tests as "absolutely horrific," language he moderated for the longer-form piece.
The academic research, by contrast, took no position on whether AI coding is good or bad and instead documented the patterns of complaint. The framing gap between the platforms is instructive: practitioners are arguing about whether to use the tools, academics are measuring the externalities, and the AI news flood thread was arguing about whether anyone should have to keep reading about it.
Our read
The shift this week is from sentiment to measurement. "AI code feels worse" became "AI code is 2x more verbose by AST analysis" and "here is the per-commit cost of an unattended run by a specific person on a specific model." These are falsifiable claims with methodology attached, and they move the conversation forward in a way that another opinion piece cannot.
The part neither the measurements nor the anecdotes address is the comparison baseline. Ronacher ran Astra unattended for 35 hours. Nobody runs a human engineer unattended for 35 hours either. The verbosity metrics compare against established repositories, not against the code a junior developer would write under the same time pressure. The fair comparison, AI-assisted developer versus unassisted developer on the same task with the same deadline, does not exist in published form yet.
When the creator of Flask publishes per-commit cost data and a researcher publishes verbosity ratios in the same week, the industry needs to answer with benchmarks that measure code quality, not just task completion. That benchmark does not exist yet.
What would change our mind: a longitudinal study comparing maintenance costs (bugs filed, refactoring hours, time to onboard new developers) between AI-assisted and unassisted codebases of similar size and purpose. Until that study exists, both sides are arguing from anecdotes, just some of them now have better numbers.
