A regression means something that worked yesterday is broken today. The bug is not new code. It is old behavior that a recent change quietly took out, and Codna is the AI debugging tool that traces it back to the commit responsible.
The problem
The commit that caused a regression rarely looks wrong. It edits one function, and the failure surfaces somewhere that never mentions it. Regression debugging by hand means reading the diff, then every caller, then every caller of those, until the chain finally connects. That is where engineers lose hours, because the symptom and the cause sit in different files and nothing links them on the page. An AI agent that tries to help by reading the whole repo burns its context on files that have nothing to do with the break, so it guesses at the symptom instead of the root. Codna closes that gap deterministically: it maps what changed and where the effect can travel, so the fix lands on the cause.
How Codna fixes it
Codna's deterministic engine builds a dependency and blast-radius graph of the whole repo in about 60ms, for zero LLM tokens and with no RAG or embeddings. It pins the recent change and traces every path the effect can reach, so the broken behavior connects back to the edit that caused it.
From that graph Codna hands the agent a tight evidence bundle of about 600 tokens, instead of the 100,000+ it takes to read the repo. The agent sees the changed code, the broken path, and the call sites that matter, then ships a fix at the root rather than a patch over the symptom.
Every fix is verified by your own test suite before it lands. Codna re-runs the test that should pass again, and the regression is closed only when the previously-passing behavior is green, at about $0.04 per verified fix.
codna fix . --issue "checkout total wrong since last release; test_apply_discount was passing"
What you get
A deterministic dependency and blast-radius graph of the whole repo in about 60ms for zero LLM tokens — no RAG, no embeddings. It links the broken behavior to the change that caused it instead of leaving you to trace callers by hand.
The agent fixes from about 600 tokens of focused evidence — the changed code, the broken path, and the call sites that matter — measured at 162x less context than reading the repo. That budget goes to the fix, not to rediscovering the codebase.
Every fix is gated on your existing test suite before it lands, so the regression is closed only when the previously-passing behavior is green again — at about $0.04 per verified fix.
The proof
Point Codna at the behavior that broke. It builds a dependency and blast-radius graph of the repo deterministically, in about 60ms for zero tokens, then traces the broken behavior back through the paths a recent change can affect. The link to the offending edit is computed from the graph, not guessed by reading files.
Most AI tools read the repo into context and then guess at the symptom. Codna does the understanding deterministically for zero tokens, hands the agent only the ~600-token evidence bundle that matters, and verifies the result against your own test suite. The fix targets the cause and is proven green before it lands.
Codna scopes the agent to the changed code and the call sites the failure actually flows through, so the fix targets the root of the regression. Your test suite then confirms the original behavior is restored before anything lands.
Codna verifies against the test that should pass for the regression. Point it at the behavior that broke; if a test guards it, Codna re-runs that test as the gate, and the fix is not considered done until it is green.
About a 600-token evidence bundle per fix, measured at 162x less than reading the repo, at roughly $0.04 per verified fix. The deterministic map itself costs zero LLM tokens.
Yes. Codna works as a CLI, as an MCP server inside Cursor or Claude, and as a native GitHub App that can triage a failing check and open a verified fix PR. For private code you can self-host with your own keys (BYOK) and fail-closed egress, with no training on your code.
Related
