One ✨, three kinds
The ✨ button next to the “Documents” heading in the sidebar (label “Create with AI — describe it, Runic writes the first draft”; signed-in sessions only) opens the Create with AI dialog. A row of three pills chooses what to create: Whole system, Process flow or Sequence diagram. Whole system is selected every time the dialog opens. Its helper text says what happens: Runic plans the product, writes every process and sequence diagram it needs, links them, then asks what the brief left open — and packages it for Claude Code and Claude Design. The other two write one new document; for a process, a brief that describes a whole operation still yields a linked set. Your existing documents are untouched in every mode.
The brief box is six rows tall for a system, three otherwise. Its placeholder for a system is a Turkish payment brief; for a process “employee requests vacation; manager approves or rejects; HR records it…”; for a sequence “a customer orders food; the app talks to the restaurant and a courier…”. ⌘/Ctrl+Enter or the Create button starts it; while it runs the button reads “Planning…”, then “Writing…” once the plan is in, or “Creating…” for a single document. Esc and Cancel work only while nothing is running, and the pills are inert while busy. Errors show as an amber note in the dialog: “Describe the product first.”, “Your brief is N characters — the limit is 12,000. Shorten it, or split the product into two briefs.”, “Planning limit reached — try again in an hour.”, “Verify your email to use AI features.”
Stage one: the plan
A whole system starts with one planning call. The brief (up to 12,000 characters — longer is refused, never cut) goes to Claude Sonnet 5 with thinking on and a 12,000-token budget, together with the names of your existing documents. The planner is told to cover the whole domain, not the happy path: every user-facing operation for every actor, corrections and cancellations and disputes, the back-office rules and period closes and reconciliation, every integration as a sequence diagram with every human in it as a lifeline, and the lifecycle of every core entity with each transition as its own process. There is no cap on counts — a real product usually needs 8 to 30 processes and 3 to 12 sequence diagrams — and two operations are never merged to keep the number small.
What it must not plan is the platform: sign-in and sessions, roles and permissions, audit logs, notification transport, exports, schedulers, settings, generic user CRUD. Those become one assumptions line that starts with “Platform”, and the documents refer to them in a step or a .note. Every name, number, threshold, role, system and channel in the brief must land verbatim in some document’s rules; nothing the brief does not say may be invented — an SLA, a percentage, an approver title, a system name — and when the answer to a question decides whether a document exists, the question is asked instead of the document being designed. The plan carries the entities with their complete status lists and, for every transition, the one process that performs it; a sequence diagram draws the wire only and never calls the process it belongs to. Names are 2 to 5 words, unique across processes and sequences, no colon, at most 80 characters; the first process is the main flow the operator starts from; 5 to 12 open questions come bound to the document they would change, founder-blocking ones first. Everything is written in the brief’s language.
The plan is then normalised on the server before anything is written. Names are cleaned and made unique; every call, forProcess, transition and question is resolved to a plan name exactly, case-insensitively, or by a single similarity attempt at a 0.8 threshold (“Prim Hesaplaması” finds “Prim Hesaplama”) — below that the reference is dropped, never guessed. A status quoted in a rule that no entity lists joins the nearest entity; rules that merely repeat a scope fragment of the brief are dropped; up to 20 questions and 40 assumptions are kept. Then platform demotion runs once: a process called by at least max(5, a quarter of the processes) other processes, owned by no user actor and owning no transition — an audit log, a notification router — is removed, unlinked everywhere and kept under “Platform, not drawn”. A scheduler drawn as a sequence goes with it when every lifeline is a system component, the brief names no timer and the diagram carries no rules. While all this runs the dialog narrates: “Reading your brief…”, “Planning every process, back-office operation and integration…”, “Pinning the brief’s facts to the documents that must carry them…”, “Listing what the brief left open…”. A plan with nothing usable comes back as “The AI could not produce a usable plan — try again.”
The live checklist
Once the plan arrives the phase line gives way to a panel: the system’s name and summary, a counts line such as “9 processes · 3 sequence diagrams · 4 of 12 written”, a “Platform, not drawn: Bildirim Yönlendirme · Denetim Kaydı” line when something was demoted, and a red warning when the plan names no entity with statuses (“each document may pick its own status words”). Below it, one row per planned document in queue order — processes first, then sequences — with a glyph for its state: ○ queued, ◐ writing (spinning), ✓ done, ✕ failed, and a process or sequence tag on the right. Rows update the moment each document’s call settles, while the others are still running. The dialog closes itself when the system has been created; if nothing could be written it stays open with “None of the planned documents could be written — <reason>. Try again.”
Stage two: every document, in three waves
Each planned document is written on its own call, up to four in flight at once, in three waves: first the main flow alone; then every document the main flow calls, with the main flow’s text as a written sibling; then the rest, with both. A sub-process sees how the main flow handles a status instead of re-deciding it, and a sequence sees the step that calls it. Up to 12 siblings travel, 4,000 characters each and 14,000 in total. A document that fails on a network error or a server error gets one more try; a refusal, a rate limit or a reply that was cut short is final. The rate limit is 300 documents an hour, the plan itself 10 an hour.
The main flow is written by Claude Sonnet 5; every other document by Claude Haiku 4.5 — both with thinking off, 8,000 tokens for a process and 5,000 for a sequence, because a document is checked mechanically afterwards. The plan travels as a cached context block: actors, entities and their statuses, the documents in the plan, the platform list, your existing documents, the assumptions. The per-document turn carries the transitions this document owns and the ones other documents own, the written siblings, the document’s own name, purpose, owner, trigger, calls and rules, its open questions, and the brief verbatim. The writing rules are strict: every rule appears verbatim; every call appears as a .do or .go with the exact name; a sequence draws the wire only; statuses are quoted from the entity list; who may run the document is a .note on line 1 (“Yalnızca Yönetici”), never a decision at the top; .input lines name concrete fields with options in parentheses; and no new nouns — where the flow seems to need something the plan does not name, the step goes as far as the plan does and a “.note karar bekliyor: …” marks the gap. That is why a generated document holds notes where you might expect decisions: they are the questions the brief did not answer.
After the write, forbidden references are downgraded rather than deleted: a .do or .go at a platform name, or at any process from inside a sequence diagram, becomes a .note in a sequence and a plain step in a process (a trailing hand-back .go at the very end of a diagram is simply removed). The document then goes through the deterministic self-repair — parse, audit, one bounded fix kept only when it scores better and loses no content — with the allowed names, the forbidden references are stripped again, and any .do or .go that still points at nothing gets one rename-only pass on the fast tier, accepted only when it resolves more targets and changes no other line. Unresolved targets are returned and named in the hand-over, never hidden.
Landing in your workspace
The entry document — the plan’s main flow, or the first written process if that one failed — is always created; on a name clash with a document you already have it becomes “X 2”. Any other written document whose name already exists is not created but linked: the model wrote your own process out again because the brief mentioned it, and a diverging copy would be worse than none. Every .do and .go in the set is rewritten to the final spelling, captions preserved. Creation order is sub-processes, then sequence diagrams, then the main flow last, so every link resolves when it opens; the main flow is created empty and types itself in while the diagram draws. In the sidebar a process with exactly one caller nests under it. If creation stops half-way — the free plan’s cap, once billing is on — the note reads “Created N of M documents — <reason>” and what exists is reloaded.
Then the chat opens with the hand-over: “<Plan name> is drafted: 9 processes, 3 sequence diagrams, linked.”, the plan’s assumptions as bullets (or “none — the brief covered everything the plan needed”), “Linked to your existing document(s): …”, “Could not write: X (reason) — run it again or add it by hand; the other documents still link to that name.”, “References with no document behind them yet: …”, “Treated as platform, not drawn: A, B (calls to A were kept as notes or plain steps).”, and finally “N open questions follow — answer them or skip; then press Build to package it for Claude Code and Claude Design.” The main flow gets the automatic structural check, the plan’s open questions start as an interview with no extra AI call, and the brief, plan and entry flow are kept for the session so Build starts pre-filled while one of the system’s documents is open.
Process flow and Sequence diagram
The two single-document modes go to one generation call: 10 an hour per account, a brief of up to 12,000 characters (refused beyond, with “split it into two documents”), a 180-second limit, Claude Sonnet 5 with thinking off, 8,000 tokens for a process and 3,500 for a sequence. A process brief is judged for scope: a narrow flow becomes exactly one document; an operation with distinct sub-operations becomes a set of linked processes separated by “=== PROCESS: name ===” markers — typically 2 to 12, more when the brief names more — the first being the main flow, each with as many steps as the brief’s detail demands, 4 for a thin stage to 40 for one described in depth. Broken cross-references get one correction pass, kept only when every link then resolves, the count did not shrink and no content was lost; every document goes through the self-repair. A sequence is always one diagram. The dialog narrates “Reading your brief…”, “Mapping the processes…”, “Drafting the steps…”, “Adding decisions and failure paths…”, “Wiring the linked processes…”, “Checking the structure…”, “Placing the boxes…”.
A single document is named from the first 44 characters of the brief, capitalised and made unique. A linked set is placed like a system — sub-processes with their text, the main flow typed in, the structural check on it — and, in a signed-in session, the reviewer interview starts: one call reads the set back and asks the questions whose answers would change the diagram.
How to use it
- Click ✨ in the sidebarNext to the Documents heading; the label reads “Create with AI — describe it, Runic writes the first draft”. The dialog opens on Whole system.
- Pick the kindLeave Whole system for a product or an operation with many parts; choose Process flow or Sequence diagram for one document.
- Describe itWrite the brief in the language you want the documents in, naming the people, the systems, the numbers and the channels you know. Up to 12,000 characters.
- Press ⌘/Ctrl + Enter or CreateWatch the phases, then the checklist: the plan’s name and counts, the platform line, and one row per document turning ◐ then ✓ or ✕.
- Read the main flow and the hand-overThe main flow opens and types in; the sub-processes and diagrams nest under it. The chat lists the assumptions, anything linked, failed or unresolved, and what was treated as platform.
- Answer the open questions, then BuildEach question opens the document it would change; your answer comes back as a diff on it. When the queue is done, press Build in the top bar to package the system for Claude Code and Claude Design.
Commands & shortcuts
| ✨ (sidebar) | open Create with AI — Whole system, Process flow or Sequence diagram |
| ⌘/Ctrl + Enter | create from the dialog |
| Esc / Cancel | close the dialog (only while idle) |
| ○ ◐ ✓ ✕ | queued, writing, done, failed — one glyph per planned document |
| Platform, not drawn: … | cross-cutting concerns the plan named but no document draws |
| .note karar bekliyor: … | a gap the brief left; the writer marks it instead of inventing |
| === PROCESS: name === | the marker that separates documents in a Process flow linked set |
| .do <name> · .go <name> | call a sub-process and continue · hand off and stop |
Tips
- Name the owners and the numbers: “sales qualifies, finance checks credit above 50,000, warehouse ships within 2 days” gives the planner its seams and its rules; what you leave out becomes a question or a TBD note, never an invented value.
- Write the brief in the language you want the system in; names, steps, notes and questions follow the brief’s language.
- If a process you already have belongs in the system, mention it by its exact name — the plan links to it instead of writing a second copy.
- A “Platform, not drawn” line is not a loss: sign-in, roles, notification transport and audit logs are assumed and referred to in notes, so the documents you care about stay in front.
- Keep one of the system’s documents open when you press Build; the seed — brief, plan, entry flow — is only offered while you are inside the system and only in this session.
- Want one flat flow? Pick Process flow and say “a single process for …” in the brief.
Questions
How many documents can a system have?
As many as the domain needs. The planner is told there is no cap and that a real product usually needs 8 to 30 processes and 3 to 12 sequence diagrams. A Process flow linked set is typically 2 to 12 documents; a sequence brief always yields one diagram.
Which models run, and does it use Opus?
The plan runs on Claude Sonnet 5 with thinking on; the main flow on Sonnet 5 with thinking off; every other planned document on Claude Haiku 4.5 with thinking off; the single-document modes on Sonnet 5. Nothing runs on Opus unless the owner sets ANTHROPIC_MODEL_HEAVY, and even then only the heavy tier, which generation does not use.
Why do the documents contain “.note karar bekliyor” lines?
The writer may not invent a noun, a status, a system or a number the plan does not name. Where the flow needs one, it writes the step as far as the plan goes and marks the gap. Those notes and the open questions are the same list; answer the questions and they turn into steps.
What if the AI references a document it did not write?
Runic checks every .do and .go against the plan and your workspace. A near miss is renamed by one rename-only pass; a reference to a platform name or, from a diagram, to a process is downgraded to a note or a plain step; anything still unresolved is listed in the hand-over message.
Will it overwrite my existing documents?
No. Generation creates new documents only. The entry document gets a numbered name on a clash; any other document that already exists by name is linked, not duplicated.
What does a failed row mean?
That document’s call failed twice, or once with a final error such as a rate limit or a cut-off reply. The rest of the system is still created, the hand-over names the failure and its reason, and the other documents keep linking to that name — ask the chat to write it, or run the brief again.