RabbinatixDocs
Sign inGet started

Getting started

What Rabbinatix is

Rabbinatix is a living map of how your software works: the systems, the API contracts between them, the flows across them and the logic in each step, so developers see what a change touches and what it breaks before it ships.

The short version

Rabbinatix is a living map of how your software works: the systems, the API contracts between them, the flows across them and the logic in each step, so developers see what a change touches and what it breaks before it ships.

AI assistants write code faster than anyone can read it. Rabbinatix keeps the picture they don't: it shows every system your team builds or depends on, and the APIs between them, on one map. It checks that both sides of every API agree, so you know which contract is broken, and who it breaks, before you deploy. Every logic and flow says whether an assistant wrote it and who accepted it.

Code you already have

You don't have to draw the map by hand. Ask the AI assistant in your editor (Claude Code, Cursor, VS Code and others) to put your repo on Rabbinatix. It reads the code on your machine and drafts the systems, their APIs, the calls between them and the main logic. Nothing is on the map until you accept it. See Map an existing repo.

  • Does Rabbinatix read my code? No. Your own assistant reads it, on your machine, and sends drafts. No AI model runs on Rabbinatix's servers.
  • What if part of my code isn't on the map? Rabbinatix says so: each system's APIs tab shows how many of the APIs in its code are on the map, and lists the rest.
  • Which assistants work? Any assistant that can use an MCP server or call an HTTP API. The setup for each is in Your AI assistant.

Design the next change

On top of the map you design how the software behaves. You draw it as flows and logic, run it with test data, and check it with test cases. Requirements, tickets and chat point at the exact flow step they are about. When it works, you take the generated code. Once the code runs, Rabbinatix keeps checking it against what you designed.

Flow-Driven Development

Flow-Driven Development (FDD) is the way of working Rabbinatix is built for. The idea is simple: you define the behaviour of a system as a flow you can run, before it becomes code.

A flow is a journey from start to finish, such as "a customer signs in" or "a customer pays". It crosses several systems. Inside each system, logic describes the steps: check the input, call another API, look something up, return an answer. You draw logic as boxes joined by connections, and you can read it as text steps too.

Because the flow runs, you can test it before anything is built. Test data stands in for databases and other systems. A test case says "with this input and this data, I expect this result". When every test case passes, the design is proven, and the code generated from it does the same thing.

The layers you zoom through

Rabbinatix never shows everything at once. You start wide and click to see more detail.

LayerWhat you seeWhere
System mapEvery system and the lines between them, coloured by healthSystem map
ConnectionAll APIs between two systems, and which ones are healthyClick a line on the map
API and contractOne API: what is sent, what comes back, and where the two sides disagreeClick an API
FlowA journey across systems, with lanes per system and a run buttonFlows
LogicThe steps one system takes, as a node graphLogic
DataWhat each step received and returned in a runA run's Step data panel

A status is never shown by colour alone. Every status also has an icon and a label.

The way of working

Most teams move through the same steps. You can start at any of them.

  1. Sketch. Draw the journey on a whiteboard with shapes and arrows. Nothing runs yet. See Whiteboards.
  2. Map. Add the systems and declare the APIs between them. Rabbinatix checks every contract. See Systems and APIs and contracts.
  3. Flow. Create the flow that crosses those systems. See Flows.
  4. Logic. Build the steps inside each system. See Logic.
  5. Prove. Add test data and test cases, then run them. See Test cases and runs.
  6. Generate code. Take TypeScript, Python, C#, Java, Go, Kotlin, Swift, Dart, PHP, Ruby or Rust that does exactly what the logic does. See Code generation.
  7. Watch it run. Health checks tell you whether a service is up, and the contract watcher checks the real API calls your frontend makes. See Health checks and Contract watcher.

Who it is for

  • Developers see what their change breaks, build against APIs that don't exist yet, and get code from the logic.
  • Tech leads and architects see the whole dependency graph, design behaviour before code, and gate deployments in CI.
  • Product owners describe journeys on whiteboards, write requirements in plain words, and see which test cases prove them.
  • QA write test cases with test data and expected results, and run them on every change.

If you don't write code, turn on Simple view. It swaps technical words for plain ones and hides IDs. See Navigating the app.

How the docs are organized

The guides follow the same order as the way of working.

SectionWhat it covers
Getting startedThis page, the quick start, organizations and Personal and finding your way around
Map your systemsSystems, the system map, APIs and contracts, statuses, imports, change impact, versions and deprecations
Build behaviourWhiteboards, requirements, flows, logic, test data and expected results, test cases, text steps, code generation and the store
Run and observeTest servers, environments and deployments, CI, health checks and the contract watcher
Work as a teamThe board, ticket automation, chat, notifications, integrations and public APIs
Manage your organizationMembers and roles, settings, plans and billing, the activity log, your data and the API

There are also reference pages: the logic editor reference, step-by-step examples, the text steps reference, the AI assistant guide and the glossary of every term.

TipIn the app, the Docs link at the bottom of the sidebar opens the docs in a new tab, so the page you are on stays as it is.