Tell your AI agent what it's about to break, before it breaks it

AI coding agents are great at editing files. They are worse at knowing what those edits touch.

You rename a field. The agent updates the obvious call sites. A controller three packages away still compiles locally, then fails in CI. Or worse: it ships, and a route that depended on the old shape starts 500ing.

The usual fix is "read more of the codebase" or "grep harder." That turns a structural question into an open-ended reasoning problem. Different runs, different guesses.

impact flips that. Before you change a file or a symbol, you ask one fast, repeatable question: what depends on this?

$ impact query src/payment/service.rs

DIRECT
  payment::controller::PaymentController::handle
INDIRECT
  order::OrderService::checkout
API
  POST /payments
EVENTS
  PaymentCreated
DATABASE
  payments
TESTS
  3 affected tests

Why this helps everyone

Agents get a checklist, not vibes. Wire it as MCP (impact mcp) and the agent can call impact_file / impact_change / impact_diff the same way every time. Same input, same graph answer. No "I think this is only used here."

Humans get the same report. You do not need an agent. impact query, impact change "rename Foo::bar", or git diff | impact diff works in a terminal for review and refactors.

PR descriptions can carry the blast radius. Reviewers cannot see your mental graph. Putting callers, routes, events, tables, and tests in the PR body is something the whole team benefits from, agent or not.

Hooks beat hope. Claude Code can run a PreToolUse hook so blast-radius checks fire on the first edit, on git commit, and when opening a PR, whether or not the model remembered the rule.

Over-report beats silent miss. When resolution is ambiguous, impact prefers listing candidates over picking one and staying quiet. False positives you can dismiss. False negatives you do not see until production.

How it works (short version)

It is structural, not a full type-checker. Tree-sitter parses the project into a symbol graph in local SQLite. Calls resolve from imports, same-file declarations, and declared binding types, with confidence tiers (Exact / Probable / Heuristic). You can filter with --min-confidence when you only want the sure edges.

Languages today: Rust, TypeScript/JSX, Python, Go, Kotlin, Swift, C++. Full API / events / database contract detection is deepest on Rust; others get strong DIRECT/INDIRECT/TESTS where conventions are clear. The core is language-agnostic; adapters plug in without rewriting the engine.

Cross-repo workspace.toml can flag shared route / event / table identities across sibling projects, labeled Declared / Strong / Weak so coincidences stay honest.

Try it in a minute

brew install ancientice/impact/impact
# or: curl -fsSL https://raw.githubusercontent.com/AncientiCe/impact-rs/master/scripts/install.sh | sh

impact index .
impact query path/to/file.rs
impact install   # MCP + rules for Cursor / Codex / Claude Code

Windows has a PowerShell install script; cargo install --git https://github.com/AncientiCe/impact-rs --locked impact-cli works anywhere with Rust.

Where we all win

Every team using AI editors is paying the same tax: agents that edit locally and miss the neighborhood. A small deterministic tool that answers "who calls this?" turns that tax into a checklist.

If you build agents, wire MCP. If you review PRs, ask for impact_diff in the description. If you maintain a polyglot monorepo, try indexing once and querying before a scary rename.

Repo (MIT): github.com/AncientiCe/impact-rs

Found a blind spot? impact report-blindspot drafts an issue so the graph can get better for the next person.

---

Built by Ionut. If shared agent memory is your other headache, that is a separate project: Palace. This post is about blast radius.