Perf work stopped being a specialist queue item, and slow endpoints became a choice
Dan Luu puts the drop in human time per optimization at 1000x and up. The one figure that survived a holdout test in his own experiment was 7 percent.
The Engineer · Build desk
What happened
- Dan Luu's essay arguing there is no reason for software to be slow anymore reached 620 points on Hacker News in about a day.
- Luu puts the fall in human time per optimization at frequently 1000x, 10000x or 1000000x, and says launching an agent on his own ripgrep usage took roughly two minutes.
- Jamie Brandon handed Anthropic's public performance takehome to Claude after his own attempt, and the agent beat him, including changes he says he would never have tried.
Why it matters
- Who has to decide decision Every backlog item closed as too expensive to verify is now a decision to re-open, because the estimate that killed it was an estimate of human days rather than of value.
- What it limits constraint The holdout has to exist before the agent runs, which means the binding limit on cheap tuning is having untouched production-shaped traffic, not having someone who knows what to try.
- Who's exposed exposure A team without that discipline now ships benchmark-shaped code to production at agent speed, and the number in the PR description will look real right up to the point it does not.
- What doesn't add up contradiction The same essay supplies both the six-order-of-magnitude headline and the single generalization-tested result of 7 percent, so a reader can leave with either an argument for rewriting everything or...
The number that moves here is not the multiplier, it is the threshold. Luu describes the old calculus plainly: look at a candidate optimization, estimate it buys 2 percent, estimate that verifying it costs N person-days, and decline [7]. That was never a judgment about whether the 2 percent was real. It was a judgment about the invoice for proving it.
Run the arithmetic on the figures in the dev.to writeup itself. It prices a specialist investigation at three days, and Luu's ripgrep agent launch at about two minutes of his own time [11][4]. Three eight-hour days against two minutes is a factor of 720 [16], which does not even reach the bottom of the 1000x-to-1000000x range Luu quotes [3]. The conservative reading is sufficient. At 720x, a 2 percent item costs less to test than to argue about in triage.
Then the holdout result, which is the part worth keeping. FRE, the agent-built regex engine, came out heavily overfit to the benchmark suite it was tuned against, and only generalized after Luu explicitly told the agent a holdout existed [8]. What survived on representative queries was 7 percent, not the 2x to 4x the easy queries showed [9]. That 7 percent is 3.5 times the 2 percent Luu used as his example of a win not worth chasing [17]. The unexciting outcome is the load-bearing one: modest honest gains, at a cost low enough that collecting modest honest gains is now rational.
The risk moves with the cost. The dev.to author points out that tuning against a synthetic load generator while production traffic looks nothing like it is an old human habit, and that an agent reaches that failure mode more cheaply and ships it faster [10]. So the scarce skill relocates. It is no longer knowing which optimization to attempt; it is holding a workload sample the agent was never allowed to see.
For JVM shops the doctrine under pressure is specific. Write boring code and let HotSpot sort it out was correct when an investigation cost a specialist three days [12][11]. The author's own list of things his teams skipped is unglamorous: a `Pattern.compile` call per request, boxing overhead in a hot stream chain, reflective lookups in a JSON path, a JDBC fetch size left at one row at a time [13]. None of that needs a JIT expert. It needs somebody with a benchmark harness and an afternoon, and the reason it never got done was that nobody had time to prove it mattered [13].
Two caveats sit on the whole argument. The author states outright that the multipliers are Luu's experiments on Luu's workloads, not his own [14]. And Michael Malis's line in the same essay, about looking at a customer's workload and adding optimizations as needed [6], describes a capability rather than a deployment anyone has reported at enterprise scale. The claim you can act on is narrower and still sizeable: the verification bill fell, so a backlog full of items marked not worth measuring is now a backlog of untested guesses.
What to watch
- Whether anyone reproduces the ripgrep or FRE numbers on a workload they did not pick themselves, with the holdout declared before the agent starts.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence40
- Adoption20
- Hype gap+45
- Incentives55
- Confidence38
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
Dan Luu published an essay titled "There's no reason for software to be slow anymore," written in response to a viral tweet claiming that critics of LLM-generated bloat would "eat crow" once everything was rewritten in hand-optimized assembly.
- [2]
Luu's essay reached 620 points on Hacker News in about a day.
- [3]
Luu quantifies the drop in human-time cost of an optimization as "frequently 1000x / 10000x / 1000000x."
- [4]
Luu had an agent do workload-specific optimization of his own ripgrep usage, and launching it took about 2 minutes of his time.
- [5]
Jamie Brandon took Anthropic's public performance takehome exercise, then let Claude pick up where he left off; Claude got a much better result. Reviewing the diff, Brandon said some of the agent's optimizations were things he had thought of but not gotten to, and others were "just crazy shit that I would never try unless I was working on this for weeks."
- [6]
Michael Malis, quoted in Luu's essay, says that with AI "we could look at a customer's workload and add [optimizations] as needed" - software fitted to a particular workload instead of a class of workloads.
- [7]
Luu describes his prior calculus: look at an optimization, estimate it was worth 2%, estimate it would take N person-days to verify, and make a judgment call.
- [8]
Luu's agent-built regex engine, FRE, was initially "heavily overfit" to the benchmark suite it trained on, and only generalized after he explicitly warned the agent that a holdout benchmark existed.
- [9]
FRE's final holdout speedup on representative queries was a modest 7%, not the 2x-4x seen on the easy queries.
- [10]
The dev.to author says overfitting to a benchmark maps onto a mistake humans have made for years, tuning for a synthetic load generator while production traffic looks nothing like it, and that an agent makes the failure mode cheaper to reach and faster to ship.
- [11]
The dev.to author states that the JVM advice to write boring code was correct when an optimization investigation cost a specialist three days, and stops being correct when the investigation costs two minutes of typing.
- [12]
The conventional wisdom in the Java world, per the dev.to author, is that the JVM's JIT handles performance, so you should write boring code and let HotSpot do its thing; JVM teams have always optimized less, not more.
- [13]
The dev.to author lists optimizations skipped on his own projects because nobody had time to prove they mattered: replacing a stream chain in a hot loop with an indexed loop after profiling showed boxing overhead, caching a compiled Pattern instead of calling Pattern.compile per request, switching a JSON serialization path to avoid reflective lookups on every call, and tuning a bulk JDBC fetch size that defaulted to fetching rows one at a time.
- [14]
The dev.to author discloses that the numbers he cites from Luu's essay are Luu's experiments, not his own.
- [15]
The dev.to author's workflow is built around one structure he calls non-negotiable, in which the agent optimizes against a separate benchmark; the supplied text cuts off mid-sentence at that point.
- [16]
Three eight-hour specialist days against two minutes of agent launch time is a reduction of 720x, below the low end of the range Luu quotes.
- [17]
FRE's 7% holdout speedup is 3.5 times the 2% figure Luu used as an example of a win he would previously decline to verify.
Get this ledger inside ChatGPT. Ask about any of our stories and the answer brings its figure, each claim’s verdict and the sources. Free, no account.
Sources
1 independent publisher whose own reporting we read for this story.
- dev.toAI Agents Can Now Optimize Your Slow Java Code: A Spring Boot Workflow That Used to Need a Specialist
1 article · August 22, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- AI Coding AgentsFollow
- Software Performance EngineeringFollow
- JVM and Java Performance PracticeFollow
- Benchmark Overfitting and Holdout DisciplineFollow