It started with Mermaid diagrams
At work, keeping AI-written code from turning into slop meant spending most of the day drawing the architecture by hand and checking agent output against it, instead of building. The code worked. It passed the tests and it ran. But it drifted from the design, a call here and a dependency there, until the diagram and the code described two different programs, and nothing said where they had parted.
Files are the wrong unit
A codebase is a graph. Functions call functions, modules depend on modules, handlers write to tables. Files and diffs are how that graph is stored and shipped, not how anyone thinks about it. When a person wrote every line, the difference hardly mattered: the author carried the graph in their head. When an agent writes the lines, nobody carries it, and a diff only tells you which text changed, not what changed in the system.
What it is
HTTP entry points. Routes requests to the domain packages; no business logic lives here.
Sessions and identity: who is making this request, and are they allowed to.
Turns a cart into a paid order.
Payments, through Stripe.
Order storage and history.
What the code talks to outside itself: services and tables, found from the calls that reach them.
So we made the graph the source of truth
In Graphide the graph is not a picture generated after the fact. It is where the work happens. You see the architecture, you plan changes on it, and agents build against it through the same tools you use. Every change, yours or an agent’s, shows up as nodes and edges changing, in the part of the system it touched. Review becomes a question of whether the shape is right, before it is a question of whether the lines are.
Checks should not be opinions
A model grading another model’s work is a second opinion, not a check. Graphide’s compliance checks are static analysis: every symbol still where the graph says it is, every HTTP route declared, every edge marked critical, like an auth check, still there in code. The same answer every time, and an exit code a git hook or a CI job can act on.
Where this is going
Models will keep getting faster and better at writing code. Within a few years a codebase will be too big, and change too quickly, for anyone to understand by reading it. People will work from a picture of it instead: what the parts are, how they connect, and what just changed. We are building that picture and making it the place you steer from, so you keep a high degree of control over your software without reading every line of it.
Where we are
Graphide is in closed alpha. We have run it on open-source codebases like fzf, Flask, Hono and Excalidraw, and we work closely with a small group of developers on their own. The product changes every week because of them. If you ship production code with agents and the diff is where you lose the plot, we would like to hear from you: hello@graphide.com.