Build1 distinct publisher2 min readPublished
A dev.to writeup grades a bug-fixing agent on its tool calls rather than its patch. Thirty documented runs cost roughly a dollar; the expensive input is the hand-built dataset behind them.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
An integration test earned its keep because someone wrote the expected intermediate state down before the code ran. Agents break that arrangement by acting. There are tool calls, multi-step reasoning, and failures that compound inside one run, where a conventional LLM eval only ever had a single output to mark [2]. Grade the output alone and you lose the why, which is the part you need in order to change anything [5]. The configuration list makes that concrete: if the baseline is a system prompt plus `read_file`, `edit_file` and `run_tests` [12], then any failure has to be attributed to the prompt or to the tools, and a pass/fail on the final patch cannot tell you which one moved.
The presence of `run_tests` in the toolset is the quiet load-bearing choice. A test suite is a deterministic checker, which is why bug fixing is the easy case for this kind of harness. Where a task has no equivalent, a trajectory score has nothing to sit on, and what is left is a semantic judge, the move the field made once surface-overlap metrics like BLEU and ROUGE stopped carrying information [13]. That does not remove the reliability question, it relocates it onto the judge.
The two suites the author separates should also never be averaged. Capability evals aim at unsolved tasks and expect a low pass rate, because the target is finding the ceiling [6]. Regression evals aim at solved ones and expect near 100%, because the target is catching breakage when a prompt is edited or the model underneath is swapped [7]. A single combined score moves for opposite reasons and reports on neither.
The arithmetic is worth doing because it removes an excuse. Three configurations over the same ten cases [11][1] is thirty documented task runs, which puts a documented run somewhere around three cents [1]. Nothing here is gated on inference budget. What is gated is labour of the unglamorous kind: each case needs a written root cause and a verification step, and the trajectory log has to record which tool was called with which parameters at which step, or the failure attribution the whole approach promises does not actually exist. That is the difference between an eval harness and a demo that passed once. The author is explicit that this was a personal experiment written up rather than a validated method [15], and the honest read of it is a shape worth copying rather than a result worth citing.
Ranked by verification strength, evidence, and original report placement.
The author built a small bug-fixing agent, planted 10 bugs in Python code, built an evaluation harness around it, and published the project open-source on GitHub.
Evaluating a standard LLM call means grading a single output, while agents take actions and rely on tool use, multi-step reasoning, and compounding failures.
If the agent hallucinates a parameter during a tool call at step two, it can silently derail the entire process, and the final answer it returns might still look completely correct.
An agent has variability: it can hallucinate into an infinite loop, take a different trajectory than intended, invent its own responses or tools, and say the work is done when it might not have been done.
The benchmark was run on Claude Haiku 4.5 for cost efficiency, and the total API spend across the entire project, including documented runs, an earlier uncaptured run and miscellaneous experiments, was approximately $1.
Capability evals focus on hard, unsolved tasks with an expected low pass rate; the goal is to find the ceiling of the agent's abilities and learn where to improve.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Self-reported experiment, published code, missing result tables
One first-person source with an open-source repo behind it, so the setup (agent, ten planted bugs, three configurations, model and spend) is concretely specified and in principle reproducible. But the supplied text omits the Run 1 versus Run 2 metric tables it advertises, no token counts or per-run costs are given, and no second publisher or third-party reproduction exists in the cluster; the normative parts of the argument - grade the trajectory, build a golden dataset, generic benchmarks are insufficient - are asserted rather than measured here.
One self-published hobby project, no external uptake
Adoption evidence amounts to a single open-source release and one benchmark execution by its own author. There are no repository metrics, downstream users, production deployments, or citations by other practitioners anywhere in the cluster, so uptake beyond the author is unobserved rather than negative.
Hedged slightly below its own evidence
The framing is unusually restrained for the genre: the author bounds the scope to task-completing agents, flags that a single flipped task shifts a ten-task score by ten points, and explicitly calls the clean adversarial result a promising signal rather than proof of robustness. The cost and design facts are modest and squarely supported. A small negative reading reflects that the disclosed caveats slightly undersell an otherwise concrete, cheap, reproducible artifact; it is not zero-aligned only because the normative conclusions reach further than the ten-task dataset can carry.
Personal visibility, no commercial or vendor stake
The author's interest is reputational: driving attention to a self-authored writeup (republished from Medium) and its GitHub repo. No sponsor, employer, vendor, funding round, or product being sold appears anywhere in the cluster, and the model used is named as a cost choice rather than promoted. The residual distortion risk is that the same person designed the agent, planted the bugs, and graded the results.
Facts of the setup are clear; conclusions rest on one voice
High confidence in what was done and what it cost - the configurations, the model, and the approximate spend are stated plainly and the code is public. Low confidence in the generalizable claims, because the cluster has one publisher, no independent verification, no visible result tables, a ten-task dataset, and only a single adversarial scenario. The derived per-run economics are solid as an upper bound but inherit an approximate self-reported total.
build
Copilot's meter changed on June 1, and half your seats are still priced in the old unit1 distinct publisher
build
AI-written code fails the same four ways, and every gate you own reports green1 distinct publisher
build
244 kB, 500 a minute, 5 percent: three ceilings that fail for the same reason1 distinct publisher
build
GitHub's traffic API forgets in 14 days, and the only key to it says 'administer my repositories'1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 26, 2026