---
title: "Blast radius in code: everything a change can break · Cork"
description: "The blast radius of a code change is the set of callers, dependents, tests and teammates' work that the change can affect, used to judge risk before editing."
canonical: "https://corkcli.com/blog/blast-radius"
last_updated: "2026-10-03"
published: "2026-10-03"
author: "Kevin Vera"
---

# Blast radius in code: everything a change can break

The blast radius of a code change is the set of callers, dependents, tests and teammates' work that the change can affect, used to judge risk before editing.

By Kevin Vera · October 3, 2026 · [Glossary](https://corkcli.com/blog/c/glossary) · 3 min read

The **blast radius** of a code change is the set of everything that change can affect: the functions and modules that call or import the changed code, the tests that exercise it, and the in-progress work of other people or agents that depends on it.

The term is borrowed from operations, where it describes how much of a system one failure can take down. In code, it answers a practical question before an edit: if I change this, what else do I have to check?

## How it works

Blast radius is computed by following dependencies outward from the changed symbol:

1. **Direct dependents.** Every call site, import, subclass or override of the changed function, class or type.
2. **Transitive dependents.** Code that depends on those, a step or more further out. The radius usually shrinks in relevance with each hop.
3. **Tests.** Tests that cover the changed code or its dependents are the ones worth running first.
4. **Live work.** For teams and parallel agents, the uncommitted or unmerged work that touches any of the above. This is the part version control cannot see until merge time.

The kind of change matters as much as its location. Changing a function's body has a smaller radius than changing its signature, and renaming a widely used type has a very large one.

## Examples

- Renaming `parse_date` in a shared `utils` module: the radius is every caller across the repository, plus any open branch or agent session that added new calls.
- Adding an optional parameter with a default: small radius, since existing callers keep working.
- Changing the return type of `get_user` from a dict to an object: every caller that indexes into the result is in the radius, and the tests for each.
- A private helper used in one file: the radius is that file and its tests.

## How teams handle it

- **Search.** `grep` or an editor's "find references" on the symbol name. Fast, but misses dynamic calls and catches unrelated names.
- **Language tooling.** Type checkers and language servers give accurate references in typed code.
- **Dependency graphs and test selection.** Build systems and test runners that map changed files to affected targets run only the relevant tests.
- **Code owners.** Map paths to the people who must review changes there.

For AI coding agents, blast radius has a second use: it tells an agent which other agents need to know about its change, and which tests to run before trusting it. Cork exposes it directly. Cork is the [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for multiplayer coding agents: it keeps Claude Code, Codex and Cursor agents, on one machine or across a team's machines, from overwriting each other on one codebase, and hands each agent what the others already learned. Its MCP tools include `blast_radius` and `get_symbol`, its briefings hand an agent the callers of the code it is about to touch, and when another agent changes code yours depends on, your agent hears it on its next step.

## Related terms

- [Semantic merge conflict](https://corkcli.com/blog/semantic-merge-conflict)
- [Semantic lint](https://corkcli.com/blog/semantic-lint)
- [Agent briefing](https://corkcli.com/blog/agent-briefing)
- [Agent collision](https://corkcli.com/blog/agent-collision)
- [Write gate](https://corkcli.com/blog/write-gate)

## Related reading

- [Blast radius: how to know what a code change breaks before you make it](https://corkcli.com/blog/blast-radius-code-change): Find a code change's blast radius before you make it: callers via LSP and git grep, dependents with Nx or Turborepo, history, tests, and teammates' work.
- [Agent briefing: the context an AI coding agent gets before it starts](https://corkcli.com/blog/agent-briefing): An agent briefing is the targeted context an AI coding agent gets before it works: signatures, callers, recent changes and notes for the code it will touch.
- [Agent collision: what it is when AI coding agents overwrite each other](https://corkcli.com/blog/agent-collision): An agent collision is when two AI coding agents change the same code, or code that depends on each other, without knowing, so one breaks or erases the other.
- [Code graphs for AI coding agents: why agents need one](https://corkcli.com/blog/code-graph-for-ai-coding-agents): Why AI coding agents work better with a code graph: fewer file reads, exact callers before an edit, and a map that stays current as several agents edit.

[All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt)

This page in HTML: https://corkcli.com/blog/blast-radius