Runic
WHY RUNIC, NOT JUST CLAUDE CODE

Claude Code builds it. Runic is where you agree on what to build.

And it keeps that agreement true while the code changes. You still build with Claude — it just starts from a spec it can check instead of a guess. And anyone can read how the system really works: your Claude writes it from the code over MCP, with file:line sources, and Runic keeps it saved, versioned and shareable.

Create a free account →Find your role
WHAT RUNIC DOES

One plain-text source, two directions

Sharing, teams with roles and working on your flows from Claude over MCP come on top. The flows sit in the middle of all of it: forward into a spec, backward from the code.

BACK FROM CODE
Your codebaseany repo your Claude can open
code-to-systemover MCP — your Claude reads the code
ONE SOURCEFlowsevery branch the code has, nothing it doesn’t
“How it works” docsfor analyst, PM or developer, with file:line sources
THE FIVE DIFFERENCES

Why not just ask Claude Code?

Claude Code builds the thing. Runic is where you agree on what to build and keep that agreement true — then Claude builds from it. Here is the short version, then each difference with the receipt.

1One durable, readable source of truth
Only Claude Code / Claude DesignThe design is agreed in a chat, then disappears into the transcript or the code.
Runic, then ClaudeA flow document the PM, the analyst and the business can read and correct — and the code is built from it.
2Deterministic checks, not a second opinion
Only Claude Code / Claude DesignModels write the happy path well and forget failure paths — differently on every run.
Runic, then ClaudeThe audit catches one-branch decisions, failures that fall into the guarded work and calls that never get a reply — the same way, every time.
3Ids from flow to test
Only Claude Code / Claude DesignClaude Code gets a vague ask, and “done” means it looks right.
Runic, then ClaudeF1.D2.yes links a branch to an acceptance criterion to a test; ten mechanical checks score the package before Claude Code sees it.
4The reverse direction
Only Claude Code / Claude Design“How does our system actually work?” is asked again in every new session, and the answer stays in that chat.
Runic, then Claudecode-to-system writes flows and “how it works” docs from the code, with file:line sources — for onboarding, audits and handovers.
5Change is cheap
Only Claude Code / Claude DesignA change of plan means a new prompt and a fresh read of everything it touched.
Runic, then ClaudeIt is text: diffable, versioned, restorable — and the AI rewrites only the lines you point it at.
1

One durable, readable source of truth

ONLY CLAUDE CODE / CLAUDE DESIGN
The design is agreed in a chat, then disappears into the transcript or the code.
RUNIC, THEN CLAUDE
A flow document the PM, the analyst and the business can read and correct — and the code is built from it.

Claude Code is very good at building. What it does not keep is the agreement: the conversation where you decided what happens when a refund is disputed scrolls away, and the next person has to read the code to find out. In Runic that agreement is a document — sentences, indentation for structure, a diagram drawn from it — that people who never read code can still point at and say “that branch is wrong”.

Customer submits a refund request
.if Order under 30 days?
.then Yes
Refund automatically
.then No
.go Manual review
2

Deterministic checks, not a second opinion

ONLY CLAUDE CODE / CLAUDE DESIGN
Models write the happy path well and forget failure paths — differently on every run.
RUNIC, THEN CLAUDE
The audit catches one-branch decisions, failures that fall into the guarded work and calls that never get a reply — the same way, every time.

Asking a model “did I miss anything?” gives a different answer each time. Runic’s structural audit is code: it parses the flow and reports the same findings for the same text, with a line number for each. It runs when you click Audit, after every change the AI writes, and from Claude over MCP before a document is saved. An AI analyst reads for meaning on top — but the floor never moves.

single-branch-decision This decision only covers "Yes" — what happens otherwise?
guard-fallthrough The "No" branch ends with a retry .back to "Enter card details", so the flow continues below the .end into "Ship the order" — the guarded work still runs.
request-without-reply “POST /charge” never gets a reply from PSP — add the response, or write it as ->> if nothing waits for one.
3

Ids from flow to test

ONLY CLAUDE CODE / CLAUDE DESIGN
Claude Code gets a vague ask, and “done” means it looks right.
RUNIC, THEN CLAUDE
F1.D2.yes links a branch to an acceptance criterion to a test; ten mechanical checks score the package before Claude Code sees it.

Every branch, failure, message, story and milestone gets an id from the position in your documents — never from the model. The spec’s acceptance criteria cite them, the kickoff tells Claude Code to write a failing test per branch id first, and its commits carry them. Ten checks — branch and message coverage, no placeholders, a number in every non-functional requirement and more — score the package out of 100 and name what fails. A checkable spec instead of a vague ask means less going back to fix.

F1.D2.yes → US-4.AC2 → a failing test named for F1.D2.yes
commit m1: refund approval (US-4, F1)
Package quality · 9/10 tells pass · score 90/100
4

The reverse direction

ONLY CLAUDE CODE / CLAUDE DESIGN
“How does our system actually work?” is asked again in every new session, and the answer stays in that chat.
RUNIC, THEN CLAUDE
code-to-system writes flows and “how it works” docs from the code, with file:line sources — for onboarding, audits and handovers.

Point your Claude at a repository and run the code-to-system prompt. It maps the entry points, entities and statuses, external systems and the rules that decide outcomes, agrees the document set with you, writes every branch, failure and retry the code has — and nothing it does not — then turns the flows into documentation for an analyst, a PM or a developer, each fact cited by file and line. The answer is saved, versioned and shared, not re-asked.

/mcp__runic__code-to-system lens: developer scope: src/billing
→ docs/how-it-works/engineering/README.md
→ ## Sources F1.D2 · F1.X1 · S1.M3 → file:line
5

Change is cheap

ONLY CLAUDE CODE / CLAUDE DESIGN
A change of plan means a new prompt and a fresh read of everything it touched.
RUNIC, THEN CLAUDE
It is text: diffable, versioned, restorable — and the AI rewrites only the lines you point it at.

Because a Runic document is text, a change is a diff you can read, a snapshot you can restore and a line you can grep. Select lines and the agent may rewrite only those lines — everything outside them is carried over verbatim. Every applied change keeps a checkpoint, and every change Claude makes over MCP is snapshotted first.

.if Order under 30 days?
- .then Yes
+ .then Yes, under $500
Refund automatically
BY ROLE

Six readers, one source of truth

Everyone who signs off on a build reads the same flow. Here is what each of them gets out of it — and where to start.

FOR THE

Founder / CEO

“Will what gets built be what I meant?”

From a one-sentence idea to a spec your developers and Claude can build without guessing.

START HERE
Idea to spec, no blank page
Describe the product in a sentence or a page. Runic plans the whole system — the main flow, the sub-processes, the sequence diagrams, linked — and asks what the brief left open instead of inventing it.
See what is being built without reading code
Every flow is a diagram anyone can open from a read-only link. When the process changes, the picture changes with it — there is no stale slide to chase.
The process is an asset you own
It is plain text: export it, keep it in your repo, read it in ten years. No proprietary canvas between you and your own operations.
Fewer expensive surprises
The audit flags the failure paths a first draft forgets — a decision with one answer, a call that never hears back — while fixing them is still a text edit, not a sprint.
A hand-off you can check
The Build Package scores itself on ten mechanical checks before anyone builds from it, and each failing check names exactly what is missing.
FOR THE

CTO

“Will the documentation still be true in a year — and what will the AI cost?”

System knowledge that stays true, checks that run the same way every time, and AI spend you can see.

START HERE
Documentation that stays true
code-to-system writes the flows and the “how it works” pages from the code itself, with file:line sources. The flows live in the repo as diffable text, and the package’s hook keeps Claude Code from rewriting them unasked.
Unhappy paths reviewed before the build
Deterministic structural checks run on every flow and every change the AI writes — one-branch decisions, guard fall-through, calls without a reply — with the same result on every run.
Spec → test traceability
F1.D2.yes and S1.M3 are assigned from your documents, never by the model. The spec, the plan, the tests Claude Code writes and its commits all join on them.
AI cost under control
Every model call is priced at list price and written to a ledger. On Runic’s key each account has $5 a month; where your own key is enabled, each person can bring an Anthropic, OpenAI or Google key and the budget no longer applies.
MCP your security review can live with
claude.ai connects with OAuth 2.1 and PKCE, Claude Code with a personal token, and agents that should only look get a read-only scope. Every edit Claude makes is snapshotted first and marked in version history.
Safe for a team, not just one person
Two people saving the same document never overwrite each other silently: the text being replaced is kept in version history and both of them are told. Removing a member ends their access at once — in the app, on the share links they made and over MCP — and revokes the team’s open invite links.
FOR THE

CPO / PM

“Are product, engineering and the business describing the same thing?”

One language for product, engineering and the business — with the missing states found before development.

START HERE
One language with engineering and the business
A flow reads as sentences to the business and as an exact contract to engineers. Everyone corrects the same document instead of three versions of it.
Missing states found before development
The audit finds one-answer decisions and dead ends instantly; the AI analyst then asks about the failure paths, roles and thresholds the flow never mentions.
Flows become test scenarios
Every branch, failure and loop becomes a Given/When/Then — in the Build Package’s acceptance criteria, or from Claude with the flows-to-tests prompt.
The backbone of the PRD
The Build Package turns your flows into user stories whose acceptance criteria cite the exact branch they cover. What nobody answered lands under Open Questions rather than being made up.
Stakeholder review without a meeting
Send a read-only link or embed the live diagram in your wiki. Reviewers always see today’s version, not the export from three weeks ago.
Check a flow from your phone
On a phone the editor shows one pane at a time — the text or the diagram — and the documents open in a drawer with search, so a quick review or a one-line fix does not wait for a laptop.
FOR THE

Tech lead

“Does this change do what we agreed — and what does it break?”

Review behaviour before code, keep ids in the tests, and let Claude Code check its own flows.

START HERE
Review behaviour before merge
The review-before-merge prompt reads a flow for structural problems, unhappy paths and naming, ordered by severity. diff_versions compares any two versions and lists the audit findings the change added or fixed.
Ids in the tests
The kickoff has Claude Code write failing tests named by branch id first and commit with the story and flow ids — so a red test points at the exact path in the flow.
Claude Code lints before it writes
Over MCP, lint_text runs the same checks without saving, so Claude fixes its own flow before it lands. Every edit it does make is snapshotted first.
See the request path a PR touches
code-to-sequence traces one request through the codebase into a sequence diagram — the real system boundaries as actors, the replies and the failure alternatives included.
Know what a change breaks
References lists every flow that calls this one, with its line; a rename updates every .do and .go that points at it across the workspace.
FOR THE

Developer

“What exactly am I supposed to build?”

A contract instead of a vague ticket — and docs for the legacy code you inherited.

START HERE
A contract, not a ticket
docs/spec.md beside your code: acceptance criteria that cite branch and message ids, a typed data model, roles and permissions, and milestones cut as vertical slices.
Sequence diagrams of the real calls
code-to-sequence traces POST /login — or any request — through the code you are in and draws what actually happens: the services, the replies, the failure branches.
Docs for legacy code, from the code
code-to-system with the developer lens writes call chains, contracts and an error catalogue, each fact cited by file:line.
Text that lives in the repo
Flows travel as docs/flows/*.runic and docs/sequences/*.runic — reviewable in a pull request, searchable, diffable like the rest of your code.
Stay in your terminal
Runic’s prompts arrive in Claude Code as slash commands. The Runic server calls no model over MCP, so your own Claude does the work on your own plan.
FOR THE

Business analyst

“How do I map this process fast — and show nothing is missing?”

Map a process by typing, make every rule and exception explicit, and use the audit as your checklist.

START HERE
Map it by typing
Write the steps as sentences and the flowchart draws itself as you type. Inserting a decision mid-flow is a line of text — nothing to drag, nothing to re-align.
Rules, thresholds and exceptions explicit
Decisions carry their branches, .fail marks what goes wrong and how the flow recovers, .note pins the rule beside its step. Where a threshold or SLA is missing, the AI analyst asks for it.
The audit as a checklist
One click lists every one-branch decision, unreachable step and dangling jump with its line number — click one and you are on that line.
Start from what you already have
Drop a whiteboard photo, a screenshot of a flowchart or a Mermaid file into the chat and the agent translates it into Runic.
Publish where people already read
Read-only links and live iframes for any page that renders one — the embed follows every future edit of the text.
Hundreds of documents, still findable
Press / to search every document by name — accents and the Turkish dotless i ignored, documents folded under a parent included — and names written like “Billing · Refunds” fold into one group per area.
THE HONEST PART

When you don’t need Runic

A solo developer shipping a small app can go straight to Claude Code — it is faster, and we would tell you so. Runic pays off as the team grows, as the process gets complex — payments, approvals, logistics, anything with many failure paths — and as the system has to live for years.

No syntax to learn first
Describe it and AI writes it. The text is there when you want precision.
Your Claude does the reading
Over MCP the Runic server calls no model — your own Claude reads your code, on your own plan.
Isn’t Mermaid in the repo free?
It is, and it is fine for a picture. Runic earns its place with the live editor, the audit, the ids and the Build Package and MCP loop — and it imports your Mermaid files when you switch.

Try it on a process you already have.

A free account takes a minute. Paste the steps, or describe the product in a sentence and let AI draft the system.

Create a free account →Every feature

Prefer to see it first? The live demo is on the home page →