RabbinatixDocs
Sign inGet started

Build behaviour (Flow-Driven Development)

Text steps

Read any logic or flow as text steps, copy or download them, and take it to your AI assistant and back.

Open Logic in the app

What text steps are

Text steps are the plain-text form of a logic or a flow. Developers know the format as Flow Pseudocode (FPC). It uses the familiar keyword style of textbook pseudocode (IF … THEN … END IF) and adds what tools need: typed inputs and outputs, CALL lines for APIs, and STEP keys that point back to the canvas.

The format is open. Anyone may read, write or build tools for it. The full reference, a cheat sheet, the grammar and an online validator are on the text steps guide.

A short example

The sign-in API's logic, as text steps:

FPC 1.0
LOGIC "Sign in (POST /api/v2/login)" KEY LOGIC-AUTH-LOGIN-001 REVISION 4
SYSTEM AuthService
ON REQUEST POST /api/v2/login
INPUT request: { body: { email: string(email), password: string } }
OUTPUT 200: { accessToken: string }, 401: { error: string }

SET user ← CALL UserService GET /internal/users/by-email WITH { query: { email: request.body.email } }
MATCH user.status
  CASE 200
    RETURN 200 WITH { accessToken: "TEST-TOKEN" }
  ELSE
    RETURN 401 WITH { error: "Invalid credentials" }
END MATCH

Keywords are upper case, every block ends with END, ← sets a value and -- starts a comment.

Read a logic as text steps

  1. Open the logic in the logic editor.
  2. Open the Text steps tab in the bottom panel.
  3. Click a line to select its step on the canvas. Select a step to highlight its lines.
  4. Use Copy as text steps or Download text steps (.fpc) to take it away.

The text steps come from the same model as the generated code, so the two agree step for step. Exports are stamped with the version or revision and the time, and say so when they include unsaved edits.

Read a flow as text steps

Open a flow and choose Text steps in the side panel. The flow reads as one document with one STEP per logic, in the order the flow runs them. A call into another system's logic is written as CALL LOGIC with its key. Click a line to open its step.

The round trip

Text steps are how logic travels between Rabbinatix and your code.

  • Out to code. Your AI assistant, connected to Rabbinatix, reads a logic's text steps and writes the code in your project, in your language. Pick a prompt from AI prompts… in the logic editor’s or a flow’s … menu, or AI prompts in a flow’s text steps panel, and paste it into your assistant.
  • Back to logic. Your assistant can also turn your code into text steps. Rabbinatix builds logic from it, matches the APIs and operations it calls to the ones on your map, and keeps the steps' keys. The result is a draft: nothing changes until you review it on the Drafts page and accept it.
  • Staying in step. Is my code in step? takes a generated file's header, or the text steps your code was written from, and tells you whether it still matches the current version and what changed since. From there your assistant can update the code for just those changes.

There is no AI inside Rabbinatix: you use the assistant you already have. See Your AI assistant to connect it.

TipPaste text steps into the validator on the text steps guide to see problems with their line and column, and the tidied form.

Where text steps help

  • Reviews. A code change can include the text steps of the logic it implements, so reviewers compare intent with code.
  • Exports. The code panel's Exported tab keeps what was exported and when, and can check a pasted copy.
  • Handing over. A developer without Rabbinatix open can still read what a logic does, step by step.

For every construct, function and type, see the text steps guide.