AI agents ship code fast. Nobody ships trust with it. Every team running Cursor, Claude, or CI bots has the same unspoken fear: the day a quick fix silently breaks the one thing that was never supposed to break.

dont-break turns that fear into a contract, in four steps:

1. Say it in plain words. "Nobody should be able to break invoice calculation, even indirectly." No file paths, no code.
2. Watch it get found. dont-break reads the live map of your codebase and lights up every place that carries that logic — including the paths you forgot existed.
3. Watch it get attacked. It writes a protection rule, then replays code changes against it to prove the protection actually holds. A dry run: nothing in your code is touched.
4. Activate it. From then on, every agent edit is checked against the rule before it lands — in the editor, in CI, on the dashboard.

30 seconds of quickstart

Requires Python 3.9+ and Node.js (npm). The graph extractor installs itself on first run.

pip install dont-break
dont-break --wake

That opens a local UI on http://127.0.0.1:4040, in your language (32 available). Sign in, pick a project folder, and the map of your code builds itself: a live 3D graph of every module, call, and dependency, with your protected zones lit up on top of it.

What "enforce it on every agent edit" actually means

Most guardrails are prompts, and prompts get ignored. dont-break sits outside the model:

• In the conversation. Connected over MCP, your agent calls check_change before editing and get_impact before refactoring. It gets told "this is riskier than it looks — 23 call sites break" before writing, not after.
• At the write itself. An editor hook intercepts every file write an agent attempts. The write is compared against your active rules — no prompt engineering, no cooperation required from the model.
• At the merge. The same verdicts run in CI and fail the pipeline when a change reaches a protected zone. What your editor tolerated, the default branch still refuses.

You:    "Rename PokemonService.fetchAll"
Agent:  → get_dependents(PokemonService.fetchAll)   "23 call sites across 4 modules"
        → get_impact(files: [...])                  "radius 3, touches ui/, cache/, api/"
        → get_do_not_touch()                        "PokemonService is a danger zone: fan-in 23, stability 31"
Agent:  "This is riskier than it looks. Here are the 23 places that break,
         and a safer 2-step plan."

That conversation happens automatically once connected. No prompt engineering: the agent skill teaches it.

Two enforcement modes

You pick the strength per folder, in one click:

Start in Watch, read a week of incidents, then flip the folders that matter to Hard.

Rules with a spine

• A rule is written in plain language, compiled against the real dependency graph, and tested by attack before activation — you see it catch a breaking change before you trust it.
• Agents can propose rules and add reasons, but they can never activate a block, pause someone else's rule, or rewrite history. Humans approve; the audit trail is append-only.
• Every verdict comes with a witness path: the exact chain of dependencies through which your edit reaches the protected zone. No "the linter said no" — you see why.

Pick your fight

"My agent keeps breaking things it never opened"
Plug dont-break into Cursor or Claude Desktop. Your agent checks impact and danger zones before editing, not after.
→ Set up in Cursor / Claude (2 min)

"I want CI to block disasters, not argue about style"
One job that fails the merge when a change hits a protected zone or a fragile hub, grounded in the real dependency graph, not vibes.
→ GitHub Actions · GitLab CI · pre-commit hook

"My team needs to see this, not just me"
Everything above runs on your machine — what your agent is doing, right now, on your working copy. dont-break.com is the other half: every repository, every agent, and what CI actually enforced on the default branch, in one place.
→ Team dashboard

"I just want to interrogate my codebase"
dbq dependents <id> | jq: who breaks if I change this? Your repo becomes a queryable database.
→ Shell + jq recipes

"I'm building my own agent"
The same 11 tools, exposed as typed TypeScript definitions or a generated OpenAPI 3.1 spec.
→ LangChain / OpenAPI / custom agents

The 11 tools your agent gets

Query tools are read-only, server-side analysis, capped responses: always safe to call. The three rule tools write team rules under tight limits: they cannot activate a block, pause someone else's rule, or rewrite reasons.

The control room

• Rule Studio: describe what must never break, watch the graph find it, test the protection live before activating it
• Check: pre-edit simulator: pick seeds, get an ok/warn/block verdict, animate the exact path a break would take
• Overview: a verdict in one sentence, stability and AI-navigability readouts, the top actions that would harden your architecture
• Graph: the Nebula 3D scene, protected zones and witness paths lit as overlays
• Agents: connect Cursor, Claude, or CI in one click, with a live try-to-break demo

Keyboard-first: cmd+K opens the command palette.

Connect your agent in 30 seconds

1. Open the dont-break app → Agents.
2. Sign in, link the folder to a project, click Connect Cursor: one click mints a project-scoped token and fills mcp.json.
3. Paste into Cursor (or your MCP client).
4. Click Install skill: it writes .cursor/skills/dont-break/SKILL.md (and AGENTS.md for other agents) so agents use the tools without being told.

Languages and capabilities

The languages dont-break maps, and what each one can actually do, live on dont-break.com/language-support.

License

Apache-2.0. See LICENSE and NOTICE.