Beyond the change itself, what does a long autonomous agent run cost you that a small assisted edit does not?

## The diff is the cheapest thing the run produced A long autonomous run ends with a change you can read, a build you can execute and, often, a green result. All of that is visible, and little of it is where the cost sits. The costs that distinguish this shape from a small assisted edit leave no trace in the diff: how many decisions the change forces into one moment, how far a mistake could have travelled while nobody was watching, how much of the session survives the session, and whether the result can be obtained again. Each is a consequence of the shape you chose, not of how well the change happened to turn out. ## Review surface: decisions per glance, not lines changed **Review surface** is the amount of judgement a change demands per human decision point. A completer offers one small unit and takes an answer immediately. A long run offers everything it did, at once, at the end. Two changes of identical size can differ enormously here: forty lines applying one pattern you have already approved is close to a single decision, while forty lines spread across a dozen files, each carrying its own judgement call, is a dozen decisions that arrive together, with one reviewer's attention spread across all of them. The same total size can therefore mean very different things: - **one pattern, many places, already approved** — close to a single decision, whatever the line count; - **many small judgements across many files** — one decision per file, and they all arrive together; - **one subtle change buried in a wide diff** — the expensive case, because the decision that matters is the one least likely to be noticed. This is why *the agent wrote it in ten minutes* is an incomplete sentence. The work did not disappear. It moved to a place where it is harder to do, because it is now concentrated, less familiar, and delivered after every decision has already been taken. What you actually look for while reviewing is a discipline of its own; the point here is only that the shape sets how much of it arrives at once. ## Blast radius: set by reach, not by severity **Blast radius** is what a mistake can touch before anyone notices, and it is determined by what the run could reach rather than by how wrong the mistake was: - **Proposal-only reach**: the worst case is wrong text in front of a person who must act before anything happens. - **Project-wide edit reach**: the worst case is a wrong change resting in a file nobody opened. - **Execution reach**: the worst case includes state that no diff displays at all. Severity is independent of this. A trivially wrong edit with wide reach can be a bigger incident than a badly wrong one that never left a proposal. How you constrain that reach, and how you recover once something has gone wide, are separate subjects with their own homes; what belongs here is that choosing the shape is already choosing the radius. ## Reconstructability: the what without the why Months later, somebody asks why a rule reads the way it does. What answers them is whatever the run recorded **at the time**: what it was asked, what it read, what it ran, what came back. A shape that leaves only a final change leaves the *what* and not the *why*, and a diff is a poor witness because it shows the decision taken and never the alternative rejected. Asking the model afterwards does not recover it either — a later account is a fresh generation, plausible and unevidenced, not a log. ## Reproducibility: a run is not an experiment Re-issuing the same request generally does not produce the same change. The sampling differs, the assembled context differs, and the state of the working copy has moved on. Two consequences follow: 1. A difference between two runs is the expected behaviour rather than a signal, so it tells you very little about whether either one was right. 2. Anything you want to keep from a run has to be captured while it happens, because there is no re-derivation later. This is the property that most surprises people arriving from deterministic tooling, where *run it again and look* is a legitimate move. ## The four costs against the two shapes | | review surface | blast radius | reconstructable | reproducible | |---|---|---|---|---| | **small assisted edit** | one small unit at a time | the edit you were watching | trivially, because you were there | not needed at this size | | **long autonomous run** | the whole change, at the end | whatever the run could reach | only what the run recorded | no | ## Answering this in an interview Price the run before you start it rather than after it. Say what reach it will have, what you expect to be able to reconstruct, and whether you can afford to review what it will produce — and be willing to say that a shape is a bad deal on a given task even though it would reach a working change faster. A candidate who can only describe the upside of autonomy is describing a demo. A candidate who can price it has run one.