Run and observe
Code impact: what a change affects
Check a code change against the map: a pull request in your pipeline, any two branches or commits, or your AI assistant's own work. Which logic, flows and contracts it reaches, which test cases to run, and whether the map still says what the code does.
Open Code impact in the appWhat Code impact is for
A code change rarely stays where it was made. A helper used by the sign-in also runs during checkout; a field renamed in an API breaks the systems that read it. Code impact answers "what does this change affect?" in the words of your map: the logic the changed code belongs to, the flows and contracts linked to it, and the test cases worth running.
It runs where your code is, never in the app. There are three ways to check a change:
- A pull request, in your pipeline: each check is a comment on the pull request (see *Set it up*).
- Two branches or commits, with the CLI on your machine: a branch against
main, two releases, last week against today (see *Compare two branches or commits*). - Your AI assistant, while it works: it finds where its change lands and checks it (see *Ask your AI assistant*).
Each check you keep shows under Code impact in the sidebar. Check a change, at the top right, asks how you want to check it. *With the CLI* gives the steps, the command and the pull request workflow; *With your AI assistant* builds the prompt from a few choices (what to check, keep the report, what to look at first, fix what broke). Both are ready to copy. A system's Code changes tab has it too: the prompt is then about that system.
How it finds the map in your code
The check reads the change on the CI machine and looks for three things:
- Logic comments. The code panel of the logic editor and Copy for my assistant write comments such as
// FDD:LOGIC-AUTH-LOGIN-001 r4 Sign inabove a function and// FDD:NODE-AUTH-LOGIN-007 Find the userabove a step. A changed line under one of them belongs to that logic and that step. - The code that calls it. In TypeScript and JavaScript, a changed function with no comment is followed back through the code that calls it until it reaches one. That answer says *likely* instead of *sure*.
- API routes and OpenAPI files. A changed API handler is matched to the API on the map: Express and NestJS (TypeScript, JavaScript), ASP.NET controllers and minimal APIs (C#), Spring and JAX-RS (Java, Kotlin), FastAPI and Flask (Python). An operation added, removed or changed in an OpenAPI file counts as an API change, and its contracts may break.
Outside TypeScript and JavaScript, a changed helper that is under no logic comment and in no API handler is listed as not on the map (see below). Test files in each language are listed as tests to run. Docs and lock files are left out.
What leaves your machine
Only keys, names, file paths, line numbers and API routes. Never your code. When nothing the change touches is on the map, nothing is sent at all. --dry-run prints exactly what would be sent.
Set it up
- Open Integrations, go to API tokens and click New token. Tick
deployas well asreadif the reports should be kept in Rabbinatix. Store the token as the secretRABBINATIX_TOKEN. - Go to API & CI and copy the workflow under *On every pull request: what it affects*. It already has your API address.
- Add it to your repository, for example as
.github/workflows/code-impact.yml. It needs the whole history (fetch-depth: 0): the change is measured from where the branch started.
Each push to the pull request updates one comment instead of adding another. Running the same commit again (a CI retry) finds the report it already kept.
By default the check only informs: nothing is blocked unless you ask for it.
Compare two branches or commits
Run the CLI in your repository with both sides. Any branch, tag or commit works, and neither needs to be checked out: the newer side is read from a temporary copy that is removed afterwards, so your checkout is never touched.
npx -y rabbinatix impact --base main --head feature/login --store # what the branch adds to main
npx -y rabbinatix impact v1.2.0..v1.3.0 --store # everything between two releases
npx -y rabbinatix impact --base main # your work in progress, with what isn't committedThe report says what was compared, with both code versions, and links to the comparison on GitHub or GitLab. It is checked against today's map: logic that changed since an older commit is shown as it is now. In CI, a shallow clone may not have both sides: fetch the whole history first (fetch-depth: 0 on GitHub, GIT_DEPTH: 0 on GitLab).
Ask your AI assistant
A connected AI assistant (Claude Code, Cursor, Copilot…) checks its own change while it works: before editing, to see what it will affect, and after, to fix what its change caused. Ask it *"Check what my change affects in Rabbinatix and keep the report"*, or *"Compare main with feature/login"*.
To keep its reports, its key needs Report findings on (Integrations → AI assistants); it keeps at most 10 an hour. Its reports show as *Checked by your AI assistant*. When it reads the code itself, everything that isn't under a step's logic comment is marked *likely*: for an answer that is the same every time, it can run rabbinatix impact instead, and the report then says *AI assistant, with the CLI*.
The Code impact page
Code impact in the sidebar lists the kept reports, newest first: the change's title, what was checked (a pull request, two branches or commits, or work in progress), who checked it (the pipeline, the CLI, or an AI assistant), and how much it affects. Pull requests, Branches and commits and From an AI assistant show only those. Red marks a critical flow, amber something to look at, grey code that isn't on the map. The newest 30 changes are kept.
A system's Code changes tab lists the same reports, only those that reach that system.
Read a report
Open a row. On the left is the change: its title, what was compared, who checked it, Open the pull request or Open the comparison, and what the check did. In the middle is the picture: where the change starts, in the centre, and around it what it reaches. The first ring is linked directly; the second ring, with dashed lines, is one step further. Hover an object to see the link that reaches it, or choose it to open What's linked for it. Only critical and Only contracts thin the picture out; All brings everything back.
On the right are five tabs:
The four answers
There is no single risk score. A score hides why; four short answers don't:
- What kind. *Behaviour changes* when logic changed, *An API changes: contracts may break* when an API did, *Only code that isn't on the map* otherwise.
- How far. How many objects in the first ring, the second, and further, in how many systems, and how many critical flows.
- How sure. *Sure* when the changed code names its logic or API itself, *Likely* when it was found by following the code that calls it, *Unknown* when part of the change isn't on the map.
- Test evidence. For the affected flows: how many last passed, how many failed, and how many were never run.
When code isn't on the map
Changed code that no logic comment, route or OpenAPI file names is listed with its file and lines. The check can't say what it affects, so it says to run all tests. Adding the logic's comments to that code (the code panel shows them) puts it on the map for the next check.
Split this change?
When a pull request changes things that affect nothing in common, for example the sign-in and the price of an order line, Split says so: as separate pull requests, each would be reviewed and tested on its own. When the parts overlap, it says splitting wouldn't make the change safer.
Out of step with the code
When a change edits the code of a logic but leaves the logic as it was, the map may no longer say what the code does. The report lists it under Risk, and the logic editor shows an amber note: "The code changed but this logic didn't: check it still says what the code does."
- See the change opens the report.
- Saving the logic again clears the note.
- If the logic is still right, Still correct clears it without a new revision. It needs permission to edit logic; everyone else sees the note without the button.
Who can do what
Your AI assistant can run the same check while it works, and list what to look at before it says it is done.
Related
- CI and the APIGate deployments in CI with the safety check and record what you deploy, using an API token and the HTTP API.
- API and tokensCreate API tokens for CI and scripts, choose their scopes, and call the REST API at /api/v1.
- LogicBuild what a system does by connecting nodes on a canvas: endpoint logic for an API, event logic for a user action, and functions you reuse.
- FlowsBuild a flow from the logic it starts at, see it cross your systems in lanes, and move it from draft to verified.
- Change impact and Draft modeSee what an API change would break before anyone feels it, share the drafts for review, and publish them when they are right.
