"Clean this up" is a request with no finish line. A person who gets it twice will usually push back and ask what is still wrong. Researchers at the University of Southern California wanted to know whether coding agents do the same.
They handed Codex and Claude Code, running five models between them, sixty small Java codebases that were already tidy, made up of textbook algorithm solutions and top-graded student projects. A simulated developer then asked for more refactoring ten times in a row, never saying what to change or why. Once the code was clean, any further edit was the agent's own choice.
"We hypothesized that a capable agent would stop once it recognized an optimized codebase; none did."
Fewer than one turn in six left the code untouched. The quality tools the team ran showed nearly all the improvement arriving in the first pass. After that, complexity and code-smell scores flattened while coupling between classes kept rising. On the small algorithm files, the worst model rewrote the equivalent of 31 times the original code before it first paused, if it paused at all.
The edits weren't disciplined restructuring either. Most were ordinary rewrites that no refactoring catalogue recognises, and every model added far more code than it removed. The model that showed most restraint early on added about 42 named code elements per codebase while deleting 7. Several models deleted things they had added a few turns before, and some put back things they had deleted.
Stopping turned out to be fragile. When an agent did decline, it usually said so plainly, often adding that the code was already good and asking for a concrete goal. Then the request came again. On the student projects, the model that stopped earliest on the algorithm files edited the code in nearly three-quarters of the replies where it said no edit was needed, and on those algorithm files it piled up more changes after its first stop than any other model.
"An agent whose “no” dissolves under repetition cannot be trusted to defend a correct one."
The authors trace this to sycophancy, the habit models pick up in training of pleasing whoever is asking. That is plausible and consistent with earlier work, but this study can't test it. It watched what the agents did, not why.
There are firmer limits too. The simulated user was deliberately a worst case, a "vibe coder" who never says what they want. Each codebase got one run per model. Everything was Java. And the team didn't check whether the code still worked after ten rounds, so nobody can say from this study whether the churn broke anything. It only shows the churn was there.
The failure sits in multi-turn sessions, which single-task benchmarks never exercise. A leaderboard score says how well an agent fixes an issue in one go; it says nothing about how it behaves the fourth time it is asked to "tidy up" a module. That fourth request is ordinary in real use, especially from people who can't judge the diff themselves.
The practical upshot is to treat an agent's "done", on this evidence, as a statement, not a guarantee. Teams that let agents iterate on open-ended work should decide up front what finished looks like, such as a specific smell removed, a complexity target met or a fixed list of files, so that a person rather than the agent calls the end. The study didn't test that, and an agent may still keep going when asked. Diff size per turn is also cheap to watch from version history alone. A refactoring session whose diffs aren't shrinking by the third turn is a good place for a human to step in.
"In a coding agent, the unit of harm is an edit, and its cost is durable: a misleading sentence can be forgotten, but an unnecessary edit must be reviewed and, once merged, maintained."
The study also cut against an easy fix. In the authors' extra tests, raising the reasoning budget didn't make the behaviour go away, and requests phrased like an experienced engineer's produced more churn, not less, which suggests the trigger is the repeated ask itself and the person making it is the one place a session can reliably be stopped.
Sources
- Jiang, H., Sabouri, S., Haghighi, S., Chattopadhyay, S., "Your Wish Is My Commit: Over-Compliant Refactoring in AI Coding Agents" — https://arxiv.org/abs/2610.36346