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.
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.
- Sketch. Draw the journey on a whiteboard with shapes and arrows. Nothing runs yet. See Whiteboards.
- Map. Add the systems and declare the APIs between them. Rabbinatix checks every contract. See Systems and APIs and contracts.
- Flow. Create the flow that crosses those systems. See Flows.
- Logic. Build the steps inside each system. See Logic.
- Prove. Add test data and test cases, then run them. See Test cases and runs.
- 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.
- 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.
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.
Related
- Quick startFrom sign-up to a first verified flow: create an organization or project, put two systems on the map, connect them with a checked API, give it logic, and prove it with a test case.
- Flow-Driven DevelopmentThe method behind Rabbinatix: describe how your software behaves as a flow you can run, prove it with test cases, then turn it into code.
- The system mapYour systems and the connections between them on one canvas, coloured by contract health, with a table and a Connections view.
- FlowsBuild a flow from the logic it starts at, see it cross your systems in lanes, and move it from draft to verified.
- Concepts and termsEvery word Rabbinatix uses, in plain words.
