1
Map the blast radius deterministically
Codna builds the dependency graph and traces every call site of the changed API across the repo — in about 60ms for zero LLM tokens, no RAG or embeddings.
Use case
Fix breakage from a dependency upgrade with Codna
A version bump turns green into red. Codna maps every call site the changed API touches deterministically, fixes the breaking changes from a tiny evidence bundle, and proves the build green again with your own tests.
The problem
Dependency upgrade breaking changes land far from the first error
You bump one package and the build lights up. A renamed argument, a moved export, a changed return type — the upgrade note is a single line, but the breaking changes ripple across every file that called the old API, often nowhere near the first stack trace. Finding all of them by hand means grepping for symbols and chasing re-exports, and missing one just means the next failure surfaces later in CI. Pulling the whole repo into an AI coding agent to find them is slow, lossy, and expensive. Codna resolves the blast radius of the changed API first, so the agent fixes the cause at every call site, not only the one that failed loudest.
How Codna fixes it
How Codna fixes an upgrade break
Whole repo100,000+
Evidence bundle~600
2
Fix every breaking change from a ~600-token bundle
The agent works from a ~600-token evidence bundle — the changed signature, the affected files, the failing build — instead of reading 100k tokens to find them, about 162x less context.
3
Prove the build green with your tests
Codna re-runs your own test suite, so the patch ships only when every call site passes and no broken caller slips into CI — at about $0.04 per verified fix.
codna fix . --issue "build breaks after upgrading requests to 2.32"
What you get
What you get
Full blast radius, not just the first error
The zero-token deterministic map resolves every caller of the changed API — including re-exports and indirect paths — so the fix covers all of the breaking changes, not the one line that failed loudest.
~600-token evidence bundle
Instead of feeding the whole repo to an AI coding agent, Codna hands it a measured ~600-token bundle — 162x less context than the 100k+ tokens a read-the-repo approach burns.
Every fix verified by your own tests
A patched call site only lands when your existing suite passes, so a behavioral change in the new version is caught before it ships — at about $0.04 per verified fix.
The proof
Fewer tokens. Faster. Verified.
Frequently asked
Point Codna at the failing build. It maps the blast radius of the changed API across the repo, scopes an AI coding agent to a ~600-token evidence bundle, fixes every affected call site, and verifies the patch against your own test suite before it lands.
Every one. The blast-radius graph resolves all callers of the changed API across the repo — including re-exports and indirect paths — so the fix is not limited to the first error the build reported.
Your test suite is the gate. Codna verifies each patched call site against your own tests, so a behavioral breaking change that affects a caller is caught before the fix ships — not masked.
An agent that reads the repo to find the call sites burns ~100k+ tokens and still misses indirect paths. Codna does the understanding for zero tokens, then hands the agent a ~600-token bundle — 162x less context — so it fixes the real cause for about $0.04.
Yes. Codna maps cross-package dependencies, so an upgrade in one package accounts for its blast radius across every workspace that imports it.
Yes, via the native GitHub App: Codna triages the failing checks on a dependency-bump PR and pushes a test-verified fix, all self-hostable with BYOK and no training on your code.
Related
