Your AI Coding Agent Just Broke 83 Files (Here's How to Stop It)

The Moment the Agent Saved Itself

A developer had Claude Code open on a postgres formatter file. The task was straightforward: refactor a small helper function. The agent returned a 12-line patch. Lint passed. Code style looked clean. It was ready to merge.

Then a custom check fired.

The agent paused. It threw out its own patch. It asked the human: do you want to split the change instead?

Why Lint Doesn't Catch This

Linters check syntax, style, and obvious errors. They don't know your architecture. They don't know that the file you're modifying is imported by 83 other files across your codebase. A single change to shared code can cascade failures everywhere those files live, but the agent won't see it without being told to look.

What happened here: the refactor was syntactically sound. Every line was correct. But the blast radius was enormous. One small change to a central piece of code would ripple through the entire dependency tree.

How the Guard Rail Worked

The developer wired a validation rule into the agent workflow. Before accepting any patch, the system checks transitive dependencies. If a change touches a file that more than 50 files depend on, it flags the risk as HIGH. The agent sees this signal and changes its behavior.

• The check runs automatically every time the agent proposes a change
• It counts how many downstream files would be affected
• If the number exceeds the threshold, the agent rejects its own patch
• The agent then suggests splitting the change into smaller, safer pieces

This is not a human code reviewer catching mistakes. This is the agent itself becoming architecturally aware and self-correcting.

What Blast Radius Means for Your Codebase

Blast radius is the scope of potential failure. When you modify a file that 83 other files depend on, you are touching 83 potential failure points. Each of those files could break in subtle ways: logic errors, integration failures, unexpected behavior that only shows up in production.

An AI agent optimizing for clean code will make the refactor anyway. It has no reason to hesitate. But you have every reason to care. By setting a threshold (50 transitive dependents in this case), you tell the agent to stop and think differently when the stakes are high.

How to Wire This Into Your Workflow

You don't need a complex system. You need a validation rule that runs before the agent's patch is accepted. The rule should measure blast radius (how many files import the modified code) and compare it to your threshold. If it exceeds the threshold, stop. Ask for a safer approach.

The source shows this working with claude Code. The agent receives the validation result and understands what it means: your patch is too risky. Would you rather split it? This gives the agent a chance to propose a safer alternative instead of forcing a human review every time.

Why This Matters for Your Team

AI agents are fast. They can refactor code in seconds. But speed without safety creates technical debt and production risk. This guard rail gives you both: you get the speed of the agent, and you keep the safety of architectural awareness. The agent learns to respect your codebase's structure, not just its syntax.

The real win is that this happens automatically. You don't have to review every patch manually. The agent does the work, the check runs, and if the blast radius is too high, the agent itself suggests a better way.

The agent paused, threw out its own patch, and asked if I wanted to split the change instead.

DEV Architecture, How I made AI agents think Architecturally