# Green Builds, Harder Changes: Two Warning Signs When a Coding Agent Keeps Extending the Same Code

> Green builds can hide a codebase that is getting harder to change. Two practitioners looked instead at what their last changes broke or undid, and a new benchmark shows why static scores don't settle it.

**Published:** November 10, 2026
**Author:** PSEEDR
**Category:** devtools
**Content tier:** free
**Accessible for free:** true
**Editorial format:** analysis
**News quality eligible:** true
**Source count:** 6
**Word count:** 2979

**Read time:** 14 min  


**Canonical URL:** https://pseedr.com/devtools/green-builds-harder-changes-two-warning-signs-when-a-coding-agent-keeps-extendin

![PSEEDR cover: the words 'Green checks. Harder changes.' beside two metal tiles with white check marks and a strained blue cable leading to a separate tile.](https://content-edge-frzs2wwjiq-uc.a.run.app/assets/article-covers/green-builds-harder-changes-two-warning-signs-when-a-coding-agent-keeps-extendin.3fe47004.jpg)

---

Builds, type checks and tests can stay green while a codebase that a coding agent keeps extending gets harder to change. Two practitioners found their warnings in the change history instead: fixes that broke unrelated paths, and agent edits that kept getting revised or undone. A new benchmark helps explain why passing checks, and even static complexity scores, leave that question open.

## Watch the analysis

[Watch the full video on YouTube](https://www.youtube.com/watch?v=xgtff-VT68U) · [Watch the Short](https://www.youtube.com/shorts/cVn1QxXeao8)

Dipak Sah, founder of [AudioForges](https://audioforges.com), builds the product alone. In a written response to PSEEDR, Sah said its Next.js frontend and FastAPI backend have been extended with Claude "almost daily since September 2026, as a solo developer." Two of those changes broke features they were never meant to touch. Removing an unused speech model "also silently removed a dependency the sign-in mailer needed, and sign-in was down for a day." Later, "a caching change meant for public pages also cached API responses, so every sign-in looked failed." Sah disclosed being a paying Anthropic customer, with no other ties.

Neither break showed up where Sah was looking. "Misleading signal: a clean type check," Sah wrote. "It caught neither break, because both were dependency and config problems, not code errors."

Mark Bietz, CMO of [Halloween Costumes](https://www.halloweencostumes.com), drew a similar line from a different setting: an internal content-governance codebase in 2025 that an agent was extending. "Build success alone was misleading because it confirmed compatibility rather than coherence, while repeated reversals exposed growing complexity," Bietz said in a written response to PSEEDR.

For anyone running a coding agent against the same live codebase week after week, that distinction is the practical problem. The build, the type check and the test suite can all stay green while each new change gets harder to make. Neither practitioner's warning came from those checks. It came from what happened to recent changes: a fix that broke a path it was not meant to touch, and agent edits that kept being revised or undone soon after. A new benchmark, in which agents keep extending their own code, helps explain why the green checks miss this, and why a static complexity score does not settle the question either.

## A benchmark that makes the agent live with its own code

The question got a timely airing on 30 October 2026, when [an episode of the AI That Works show](https://www.youtube.com/watch?v=VLonoD9m4VY) walked through a fresh run of SlopCodeBench. The hosts are Dex, CEO and co-founder of HumanLayer, and a co-founder of Boundary, the company behind the BAML programming language. One of them reran the benchmark on recent models and credited the University of Wisconsin team that built it.

Most coding benchmarks hand a model one complete task and score the result. [SlopCodeBench](https://arxiv.org/abs/2603.24755) (Orlanski et al., revised 7 May 2026) takes a different approach. It gives an agent 36 problems split into 196 checkpoints. "Each checkpoint is a fresh feature starting from the prior checkpoint's workspace," the paper says. An agent's early design choices therefore become the foundation it must build on later. "So, we force it to build on its own slop," as one of the hosts put it.

The scoring is the important part. A checkpoint counts as strictly passed only if its own tests pass and all tests from earlier checkpoints still pass. The paper numbers the checkpoints C1, C2 and so on, and spells out the consequence: "Because regression tests carry earlier requirements forward, a mistake at C2 can zero out later checkpoints even if later code partly works." By that standard, the best agent the authors tested passed 14.8% of checkpoints, and no agent solved any problem from start to finish. One of the hosts described the everyday cost behind this design: over time it gets harder to "fix something over here without breaking two things over here," and "that is what slows us down."

The episode's headline claim is that one model did better at a medium effort setting than at its highest. That rests on a single run by the hosts, with each model running in its own default tool, and the host who ran it allowed that the result might simply reflect the shape of the benchmark. This article does not rely on it. What matters for a team is the benchmark's design. It separates "this change works" from "this change didn't break what came before."

## What the green checks confirmed

Sah's two breaks show why that separation matters. A type checker compares code against the types the code declares. On PSEEDR's reading, two things fall outside that comparison: whether a package that another feature needs at runtime is still installed, and which routes a cache rule ends up covering. The code can be type-correct while the running system is broken. Sah did not describe the cache layer or how dependencies are managed, and this article does not guess at them.

Bietz's phrase, compatibility rather than coherence, names the split. Together, a build, a type check and a passing test suite confirm that a new change fits the existing code well enough to compile and to satisfy the behaviors someone wrote tests for. None of them asks whether the codebase still holds together as a design, or whether the next change will affect only the part it is meant to.

That does not make the checks useless. Sah kept them: under the current process, "TypeScript and ESLint must pass before any push." The point is narrower. A check can be a good gate that stops a known class of error and still be a misleading measure of health.

## Static scores leave the question open

The obvious next step is to add complexity metrics and watch them. SlopCodeBench is a useful test of that idea, because it measured both code quality and pass rates at every checkpoint.

Quality got worse as agents extended their own code. The paper measures "structural erosion": how much of the code's branching complexity piles up in functions that are already complex. Erosion rose in 77% of agent runs. Verbosity, the paper's measure of duplicated and redundant code, rose in 75.5%. The authors note that "pass rates can remain stable even as the underlying code becomes harder to extend," and that the rise in complexity "would be invisible without iterative evaluation."

In an appendix, the authors check whether these quality scores, taken at one checkpoint, predict what happens at the next. Their erosion score had a correlation of −0.018 with the next checkpoint's pass rate. Across the variants they tried, "predictive correlation with next-checkpoint pass rate stays near zero, while predictive correlation with next-checkpoint cost stays positive." For erosion, the cost correlation was 0.167. Plain size predicted cost better. Lines of code correlated 0.502 with the next checkpoint's cost, and the highest cyclomatic complexity of any single function (roughly, its count of decision branches) correlated 0.356. "Size-heavy baselines such as LOC and max CC remain stronger raw cost predictors," the authors write. For predicting a pass, even lines of code, the strongest of the listed measures, reached only −0.212.

Two limits apply. These are Python results on benchmark problems, not measurements of production codebases like Sah's or Bietz's. And the paper does not say complexity metrics are useless: size in particular tracked how costly the next checkpoint would be. The narrower lesson is that, in this benchmark, a score describing the code as it stood said little about whether the next change would pass. The benchmark did not test history-based signals like the two in this article, so it is no evidence that they would do better. What it shows is that a snapshot score left the question open, and the two practitioners answered it from a different source: what their recent changes actually did.

## The risk is specific, not universal

None of this means AI-written code always becomes harder to change. [Echoes of AI](https://arxiv.org/abs/2507.00788) is a preregistered experiment by Markus Borg and colleagues with 151 participants, 95% of them professional developers. One group added a feature to a Java web app, with or without AI help. Other developers then extended that code without AI. The authors "did not detect systematic maintainability advantages or disadvantages." The study ran in late 2024, before today's coding agents. It covered one feature rather than a long sequence of changes, and its second phase had too few participants to reliably detect medium-sized effects. It sets a boundary on this article's argument rather than refuting it.

SlopCodeBench also compared agent runs with the histories of 473 maintained Python repositories. Erosion rose in those projects too, in 53% of the repositories examined, but far more slowly per step: 0.0053 per checkpoint against 0.0264 for agents. That comparison is observational, and the authors note that commits made after 2022 could include AI-assisted work.

Taken together, the evidence points to a specific risk: an agent repeatedly extending its own code without anyone consolidating it. Short, reviewed additions are a different situation. That is the setting in which the next two signals matter.

## Signal one: a fix that breaks something it wasn't meant to touch

"The signal I relied on was fixes breaking something unrelated," Sah wrote. In the first case, nothing in the change pointed at sign-in; as Sah describes it, the connection ran through a dependency. In the second, a cache rule written for public pages also covered API responses.

Software-evolution research has a name for this kind of hidden link. "Change coupling is an implicit relationship observed when artifacts change together during software evolution," Igor Wiese and colleagues wrote in [a 2015 study of the Apache Aries project](https://doi.org/10.1007/978-3-319-17837-0_1). Summarizing earlier research, they note that change coupling "reveals relationships between software artifacts that cannot be found by scanning code or documentation." They cite findings that change couplings correlate with defects, including a study by Cataldo and colleagues of two software projects at different companies. There, the effect of change coupling on fault proneness, roughly how likely code is to contain faults, was "significantly more relevant than the impact of structural coupling", the kind of link you can see by reading the code. In the Aries data, more than half of the strong change couplings in the releases with the most couplings were associated with at least one defect.

On PSEEDR's reading, that is why a break in an unrelated path deserves more weight than an ordinary bug. An ordinary bug says this change was wrong. A break in a path the change was not meant to touch says something more: the codebase contains a relationship that neither its structure nor its type system shows. The next change near that area is likely to run into the same hidden link, and can again break code nobody thought to check. The Aries study found that strong couplings tend to recur in the following release.

The caveats matter. This research predates AI coding agents, and it links change coupling to defects, not directly to how hard changes become. It explains a mechanism. It does not prove anything about agent-written code in particular. Tool vendors that mine version history for these links add another caution. [CodeScene's documentation](https://codescene.io/docs/guides/technical/change-coupling.html) says "Change coupling in itself is neither good nor bad" and recommends comparing the coupling you observe against your intended architecture, since "Any deviations might indicate real problems." A break in an unrelated path is one of those deviations, discovered the expensive way.

## Signal two: agent changes that don't stay changed

Bietz watched a different signal. "In an internal content-governance codebase in 2025, reversal rate became the clearest warning sign," Bietz wrote. "Although no formal percentage was tracked, changes made quickly by the agent were increasingly revised or partly undone during the next development cycles."

Bietz also named the cause: "The problem was not faulty syntax but the agent meeting immediate requests while quietly duplicating decision logic." On PSEEDR's reading, duplication explains why reversals pile up. When the same decision lives in two places, a later change can update one copy and miss the other, and someone then has to come back and make the two agree again. A reversal can be the visible trace of that cleanup.

The idea has a measurable counterpart. GitClear, which sells code analytics, [defines code churn](https://www.gitclear.com/coding_on_copilot_data_shows_ais_downward_pressure_on_code_quality) as "the percentage of lines that are reverted or updated less than two weeks after being authored," and has tracked it across about 153 million changed lines. That is not the same as Bietz's observation, which was informal and uncounted, and GitClear's pages do not explain how they decide which changes came from AI. But the definition shows that a team that wants this signal can count it from its own history. SlopCodeBench's verbosity measure, which counts cloned code, tracks a related pattern from the code side.

The two signals look in opposite directions. Sah's asks what else broke when a change shipped. Bietz's asks whether recent changes stayed in place. Both concern the history of recent changes, not the state of the build.

## Reading the signals side by side

Signal

What a pass or value confirms

What it cannot see

Evidence in this article

Type check and lint

Code agrees with declared types and lint rules

Runtime dependencies; which routes a config rule covers

Sah: caught neither of the two breaks

Build success

The change compiles and fits the existing code

Duplicated decision logic; whether the design still holds together

Bietz: "compatibility rather than coherence"

Tests, including regression tests

Behaviors someone wrote tests for still work

Paths no test covers; gradual structural decay

SlopCodeBench: pass rates can stay stable while code gets harder to extend

Static complexity score at one point in time

Where complexity sits now

Whether the next change will pass (erosion correlated −0.018 with the next checkpoint's pass rate; size tracked cost better)

SlopCodeBench appendix (Python only)

Unrelated break after a change

A hidden relationship exists outside the intended path

Only visible after the change runs somewhere real

Sah; change-coupling research

Reversal of recent agent changes

An earlier change did not fit; logic may be duplicated

Needs history; easy to miss without a count

Bietz (no formal count kept); GitClear churn as a measured counterpart

## What each of them changed, and why it fits where the problem lived

Neither practitioner reported numbers on whether the changes worked, and each account is a single case. Sah works alone on one product, and Bietz kept no count of reversals. What follows is what they changed, not proof that it works, and not a measure of how often these signals fire across teams. The useful pattern is that each moved the check to where their own problem actually appeared.

Sah's breaks appeared in the running system, so that is where Sah added a check: "a one-command health check tests real endpoints with deliberately bad input after every deploy." Sah also changed the start of the process, so that "the agent writes test scenarios (normal, edge, extreme) before building anything." And the shipping rhythm changed: "Changes now ship as one complete batch instead of many small follow-up fixes." On PSEEDR's reading, that last change targets the pattern the signal exposed: a change ships, its side effects surface, and a string of small fixes follows. The type check and lint stayed as a gate before every push.

Bietz's problem was duplicated decision logic, so the response went after duplication at its source. "A rule catalog was introduced to make the process more consistent. The agent had to identify the relevant rule before making edits, while missing rules required human input first. Duplicated paths were consolidated during routine maintenance."

That catalog differs from telling the agent to write cleaner code, and the benchmark hints at why the difference may matter. In SlopCodeBench, "Explicit quality guidance reduces initial verbosity and erosion by up to a third, without affecting degradation rates." Better instructions lowered the starting point, but the code still got worse at the same pace. The trigger episode's hosts described their own guidelines experiment for code in their BAML language, which improved most of the complexity metrics they tracked. Those runs cannot speak to this question, though: they started each project from scratch, and one host noted on air that the code did not accumulate over time. Bietz's catalog adds something a prompt does not: when no rule covers a decision, the edit waits for a person. Bietz's account did not measure whether that slows the decay.

## When to stop adding and consolidate

Back to the opening question. Builds, type checks and tests answer whether a change is compatible with the code you have. They do not answer whether the next change will be easy. In SlopCodeBench, a static complexity score did not answer it either: it said almost nothing about whether the next checkpoint would pass, though code size did track how costly it would be. Keep the checks as gates, because they still stop real errors.

To judge whether the area you are working in is getting harder to change, look at two pieces of its history. Did the last change break a path it was not meant to touch? Have recent agent changes there been revised or partly undone soon after? If either is happening, the two practitioners' experience and the change-coupling research give reason to pause feature work in that area and consolidate first. Find the hidden link or the duplicated decision, give it one home, and put a check where the break would actually appear. Sah put that check on the deployed system. Bietz put it on the rule each edit depends on.

What remains open is how a small team can count these signals cheaply. Some links between files are expected, such as tests that change along with the code they cover, and a count that flags those would soon be ignored. Which unrelated breaks and reversals are worth tracking, and how to see them without building a dashboard nobody reads, is a question that teams who have tried it could help answer.

---

## Sources

- https://www.youtube.com/watch?v=VLonoD9m4VY
- https://arxiv.org/abs/2603.24755
- https://arxiv.org/abs/2507.00788
- https://doi.org/10.1007/978-3-319-17837-0_1
- https://codescene.io/docs/guides/technical/change-coupling.html
- https://www.gitclear.com/coding_on_copilot_data_shows_ais_downward_pressure_on_code_quality
