New Map an existing repo with your own AI assistant

AI builds software faster. Rabbinatix helps developers understand it better.

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.

Questions answered: what it is, what breaks, who changed it
3
Visual logic blocks
120+
AI models running on our servers
0

Built for developers who code with AI, and everyone they show the picture to

Backend developers Frontend developers Tech leads Architects Platform teams Engineering managers Product owners QA engineers Founders Business analysts

See it. Know what breaks. Know who changed it.

See what your AI wrote. Then change it on purpose.

Rabbinatix keeps the picture your assistant doesn’t: the systems, the API contracts between them, the flows across them and the logic of each step. Understand the code you have first, then design the next change on the same map.

Put the code you have on the map

Ask your own AI assistant to map a repo. Its systems, APIs, calls and main logic arrive as drafts you review and accept, and each system says how much of its code is on the map, and what isn’t yet.

  • Your assistant reads the code, not our servers
  • Drafts you accept, never live edits
  • “18 of 24 APIs on the map”

Know what a change breaks

Every API contract between your systems is checked field by field as it changes. Try a change in Draft mode and see which callers and fields break before you save it.

  • Field by field contract checks
  • Draft mode before saving
  • Safety check for your pipeline

Know who changed what

Every logic and flow says whether an assistant wrote it and who accepted it. Changes to critical flows can need an approval, and the dashboard shows where the risk is.

  • Written by an assistant · accepted by Ana
  • Approval for critical flows
  • Where the risk is

Walk through it, ask it

Step through a flow one step at a time in plain words, or ask the map: what does this call, where is this used, which flows have no test cases. Answers link to the exact step.

  • Walk through any flow
  • Questions in the command palette
  • Flows changed this week

Then design the next change: whiteboards and requirements

Start where ideas start: sketch the journey on a whiteboard, review it together, and turn it into flows and tickets. Requirements stay linked to the flows and runs that prove them.

  • Review and turn into work
  • Requirements linked to runs
  • Turn notes into tickets

Flows

A login, a checkout, a sign-up: one journey across every system it touches, step by step, with the API each step calls.

  • Critical flows on the dashboard
  • Impact of a change, per flow

Visual logic

Build what each step does with blocks: validate the input, look something up, decide, call another system, answer. It also reads as plain text steps, and anyone on the team can follow it.

  • 120+ building blocks
  • Quick test as you build
  • Reads as text steps

Data and test cases

Test data and expected results give the steps real data to work with. Test cases become acceptance tests you play, time-travel through and keep.

  • Play and time-travel
  • Every run kept

Verified code

Every piece of logic becomes typed TypeScript, replayed against your test cases before you download it.

  • Line ↔ block links
  • No framework lock-in

Flow and logic store

Free sign-in, registration and utility logic. Fit it to your systems, copy it in, or publish your own.

  • Clear version numbers
  • Preview before import

Built for the whole team

Broken contracts and failing test cases open tickets on the board by themselves, linked to the exact step. Every system has a chat channel, and health checks and the contract watcher keep the live system in line with the design.

  • Board, sprints and views
  • Chat with live status
  • Health checks and the watcher

From flow to code

Logic you can see, code you can trust.

In Flow-Driven Development the flow is the specification. The code Rabbinatix generates behaves exactly like it: it is replayed against every test case before you download it, and every line links back to the block it came from.

  • Verified against your test cases

    Generated code runs with the recorded inputs and answers, and must take the same path.

  • No lock-in

    Plain TypeScript with typed interfaces for the systems it calls. No runtime dependency.

  • Linked both ways

    Hover a line to light up its block; click a block to find its lines.

sign-in.ts
1// sign-in.ts · generated from LOGIC-AUTH-LOGIN-0012export async function signIn(request: SignInRequest, deps: SignInDeps) {3  const email = request.body?.email ?? null;4  if (!checkEmail(email, 'email').valid) {5    return { status: 401, body: { error: 'Invalid email' } };6  }7  const user = await deps.users.findByEmail({ email });8  switch (user.status) {9    case 200: return issueToken(user.body);10    default: return { status: 401, body: { error: 'Invalid credentials' } };11  }12}
⎇ LOGIC-AUTH-LOGIN-001 rev 3✓ 5/5 test cases verified

Use cases

Software that works as designed.

Browse the store
Product teams

A new feature

Product owners design the flow, developers download it

Sketch a sign-up on a whiteboard, turn it into a flow across your systems, prove it with test cases before the backend exists, then hand developers typed code that already passes them.

needed to run the test cases
No backend
code, replayed against them
Typed
  • Whiteboards
  • Flows
  • Code generation
Platform teams

Many services

Every service on one map, every breaking change seen first

Import your OpenAPI, Postman or browser recording (HAR) files. What each caller expects is checked against what each provider offers, and every affected flow and team is named before the change goes live.

by field contract checks
Field
impact of a change
Per flow
  • System map
  • Contract checks
Any team

Start from the store

Sign-in and registration from a free template

Fit a free store flow to your own identity provider and systems, keep its test cases, and copy it in or download its code.

free official packages
75
test cases when you adapt it
Kept
  • Store
  • Test cases

How Flow-Driven Development works

From a sketch to verified code in six steps.

  1. 01

    Sketch it

    Draw the journey on a whiteboard with your team: the screens, the systems, the questions. Review it, then turn it into flows and tickets.

    Ideas become flows and tickets, not lost notes.

  2. 02

    Map the systems

    Add your apps and services, or import OpenAPI, Postman and browser recording (HAR) files. Connect them and say what each one expects from the next.

    Contracts are checked from the first line.

  3. 03

    Design the flow

    Lay out the journey across the systems, step by step, each step calling a real API. Or start from a free store flow.

    Requirements link to the flows that meet them.

  4. 04

    Build the logic

    Give each step its behaviour with visual blocks, and its test data and expected results.

    Anyone who prefers text can read it as text steps.

  5. 05

    Prove it

    Write test cases for the normal case and the unusual ones, play them across your systems and step back through any run.

    Acceptance tests before the code exists.

  6. 06

    Release it and keep it true

    Download typed TypeScript verified against every test case. Health checks show what is up or down whenever you open the Connections view, and the contract watcher flags calls that stop matching the design while you develop.

    Plain code. No runtime, no lock-in.

Works with the tools you already use

Bring your specs in, take your code out, and keep your team in the loop.

OpenAPIPostmanHARPactTypeScriptAngularReactNode.js
NestJSFirebasePostgreSQLGitHubGitLabMCPWebhooksCI / CD

Pricing

Start free. Grow when your team does.

Every plan is the whole platform: whiteboards, the map, flows, logic, test cases, code and the store. Pay for more people and more systems.

Planned prices, after early access. Rabbinatix is free during early access, with Enterprise's limits for every workspace. These are the prices we plan to charge afterwards; you'll get at least 15 days' notice before anything is charged, and nobody pays without choosing a plan.

Free

Freeforever

The whole product, free for one developer or a team of up to three.

  • Free for individuals and teams of up to three
  • Up to 3 projects and 10 systems
  • 1 GB of files
  • Whiteboards, flows, logic and test cases
Get started

Standard

Most teams

$12per member / month

For teams of four or more, with team work and the AI assistant in chat.

  • Unlimited members
  • Up to 25 projects and 50 systems
  • 20 GB of files
  • Everything in Free
Get started

Premium

$15per member / month

For organizations that sign in with their own identity provider. At least 5 members are billed.

  • Unlimited members, projects and systems
  • 100 GB of files
  • Everything in Standard
  • Single sign-on (SAML, OIDC)
Get started

Enterprise

$18per member / month

For organizations that need an uptime commitment and a security review. At least 10 members are billed.

  • 500 GB of files
  • Everything in Premium
  • 99.9% monthly uptime commitment (SLA)
  • A security review for your procurement
Get started

Custom terms

For organizations that buy by invoice or contract: any plan, on terms we agree with you.

Need an invoice, a contract or custom terms? Contact us

Members, projects, files, calls, assistant calls, health checks, history and fair use, plan by plan: Compare plans

Why Rabbinatix

Code got faster to write. Not faster to understand.

AI assistants write working changes in minutes. A developer reviews them one diff at a time, and nobody holds the picture: which services a change touches, which API another team relies on, which step nobody designed, who accepted it. The bugs live in those gaps: a field someone renamed, a caller expecting something nobody promised, a case nobody tested.

Rabbinatix keeps that picture as one living map: the systems and their contracts, the flows across them, the logic of each step, checked as it changes. Your own assistant helps fill it in; you review what it adds. Plain enough that product owners and QA can follow it, and exact enough to generate and verify the code.

logic building blocks
120+
steps from sketch to code
6
free store packages
75
extra libraries your generated code needs
0

See your own code on one map.

Tell us what you are building and we will set up a walkthrough with your own systems. Or sign up, ask your assistant to map a repo, and review the map in minutes.

  • Metro Manila, Philippines
What is it about?
How many systems?