Two engineers hand a coding agent the same bug and get different bills, and the difference is not the model. Across 2,700 runs on five real repository bugs, cutting a full eight-section specification down to a bare user story raised token spend by 29.7% and turns by 16.4% while the solve rate moved by less than two points. How much it costs is task-dependent — 13% on one bug, 115% on another — and turning the thinking effort up compresses the difference rather than removing it. Run-to-run noise is small and unmoved by anything you write, which is what makes the brief a lever rather than a rounding error.
The experiment takes one specification template with eight sections — user story, requirements, acceptance scenarios, success criteria, entities, edge cases, assumptions, header — and builds twelve variants of each bug report from it. Seven remove exactly one section. Two keep only part: contract is the header plus requirements plus success criteria; minimal is the header plus the user story. Two more are anchors kept outside the main analysis. Step through them and watch the prompt shrink.
Note the scale. The whole difference between the fullest and the thinnest brief is a few hundred tokens of writing, sitting on top of a shared scaffold of about 1,100. That is the entire input side of the lever, and it moves a run that costs dollars.
Pooled across all five bugs, replacing the full specification with a bare user story raises cost by 29.7% and turns by 16.4%, and the direction is the same on every task. The solve rate barely moves — down 1.9 points with a confidence interval straddling zero — so this is not a quality trade so much as a straight transfer: work you did not do in the brief gets done by the agent, at token prices. But the size of the transfer is wildly task-dependent.
The single-section removals are the practical finding. Dropping the acceptance scenarios alone — one section — costs 11.6% more tokens and 7.0% more turns. That is more than a third of the full effect from omitting one part of the template, and it is the part most teams skip first.
The same grid was run at three thinking efforts. Effort dominates: the geometric mean spend per run goes from $0.117 at low to $0.561 at max, and per task the ratio between the two runs from 3.62× to 6.47×. The prompt's leverage shrinks as effort rises — the gap between the most and least expensive specification narrows from 2.13× to 1.61×. Writing a good brief matters most exactly where you are least likely to bother: on cheap, low-effort runs.
The last piece is a predictor. Fitting a shared cost shape across the specification-by-effort grid on four tasks and transferring it to a fifth gets you nowhere on its own — the absolute level of a new task is not predictable from other tasks. Add one cheap probe run on the new task, at the full specification and low effort, and that single number fixes the level while the borrowed shape supplies everything else. Toggle the probe.
Run-to-run noise is what makes this work. Repeats of an identical configuration have a median geometric standard deviation of 1.34×, the range across specifications is only 1.29× to 1.40×, and absolute spread scales almost exactly with average cost. Nothing you write changes the variance — it changes the level, which is the only thing a probe needs to pin down.
The production shape is a team pointing a coding agent at a queue of tickets, some written properly and some pasted in as one line. The per-task median costs and the per-task uplift from a thin brief below are the paper's measured numbers; the ticket volume and the share written thinly are yours. The second meter is the budget you should actually hold, at the paper's 1.9× multiplier for 90% confidence.
The uncomfortable version of this result: the cheapest way to cut an agent bill measured here is not a smaller model or a shorter prompt. It is fifteen more minutes of writing per ticket, and the effect is largest on the tasks you cannot predict in advance.