Matrix · Essay
Why I Created Matrix Designer Giving AI a brain before it writes code
AI can write code in seconds — but software needs an intention before the first line. This is the story of the brain I built to give it one.
1 · The blank page
There is a moment every builder knows. You have an idea — an app, a game, a tool — and for a few minutes it is perfectly alive in your head. You can see the whole shape of it. Then you ask an AI to write the code, and the code arrives almost instantly, fluent and confident. And something is quietly, deeply wrong: the pieces do not fit. There is no architecture holding them together, no art direction, no plan for the assets, no definition of what "finished" even means. You have a pile of fluent fragments where a system should be.
I could not let that gap go. The hardest part of building anything with AI is not writing the code — it is knowing what the whole solution should become before you split it into pieces. Without that, every generated batch improvises, and improvisation at every step does not add up to a product. It adds up to a demo that falls over the moment you lean on it. The model was never the problem. The missing thing was intention — an architecture, a set of goals, a contract — decided before the first line of code.
"AI made writing code almost free. It made deciding what the code should be the scarce thing."
2 · A physicist's reflex
For ten years before any of this, I computed nuclear matrix elements — the quantities that decide whether an exotic nuclear reaction is even allowed to happen. In that world energy does not approximately balance. It balances exactly, to the last decimal, or the calculation is simply wrong. You do not get to wave your hands. The universe is keeping the books, and your only job is to keep them as carefully as it does.
That training leaves a mark you do not get to put down. When I moved from physics into machine learning, and then into autonomous AI, I assumed I was leaving conservation laws behind. I was not. The same reflex runs through everything I build now: a system is only trustworthy when every quantity it depends on has been named, accounted for, and constrained. Watching an AI spray edits across a repository with no scope, no acceptance test, and no record of why, my physicist's reflex fired exactly as it would at a calculation that quietly invents energy. Something was being created out of nothing, and nobody was keeping the books.
So I did the thing the discipline demanded. Before execution, a design. Before action, a constraint you can audit. That reflex became three open-source projects — a brain, a contract, and a worker — and the rule that ties them together: Matrix Designer designs the solution, Matrix Builder controls the build, GitPilot writes the code, and Matrix Definitions enforce the rules.
3 · The brain
Matrix Designer is the part I want to talk about first, because it is the part the industry skipped. Give it an idea — say, "an arcade platformer with four levels for the web" — and a team of specialist LLM agents does not write a single line of code. Instead they design: they choose the stack, sketch the architecture, define the user flows and the visual target, write the entity contracts and the asset manifest, set the acceptance criteria (including how it should look), and lay out an ordered, dependency-aware roadmap of build batches. The output is one governed, content-addressed Design Bundle — a signed blueprint that explains why every part exists and how the parts fit.
It proposes three options at once — Minimal, Standard, Production — so you choose your ambition instead of negotiating it one prompt at a time. And it never approves its own work: a quality agent checks the design against open governance rules, because a brain that grades its own homework is not a brain you can trust. Run it below.
4 · The contract
A design is intention. The next question is enforcement, and that is Matrix Builder. It takes the Design Bundle and turns it into a Matrix Bundle — a signed contract an AI coder must obey: a blueprint, locked coding standards, an allow-list of exactly which files may change, and the acceptance criteria the result will be judged against. The slogan is the whole philosophy in five words: give AI coders a contract, not a prompt.
The difference is not cosmetic. A prompt is a wish; a contract is a boundary. With a prompt, an edit can land anywhere and nobody can later prove what changed or why. With a contract, edits outside the allowed scope are rejected automatically, and at the end a validation engine marks the work approved, needs-repair, or rejected. Toggle the two worlds below and watch the same AI behave under each.
5 · The worker
Only now does code get written, and the worker is GitPilot — not a single model behind a chat box but a small team of agents. Explorer reads the whole repository and its tests. Planner drafts a step-by-step plan you can read before anything moves. Coder writes and runs the tests, fixing itself when they fail. Reviewer validates the result and drafts the commit. You choose how much rope to give it — Ask (approve each action), Auto (run freely), or Plan (read-only).
And here is the line I care about most: GitPilot is never the final authority. It reads the Matrix Bundle, implements inside the contract, and returns a controlled diff — it does not approve its own work or commit past the governance gate. The same reflex that keeps a physics calculation honest keeps an AI coder honest: the thing that decides is never the same thing that acts.
"AI helps write the code. But the thing that decides is never the same thing that acts — that is the whole design."
6 · The pipeline
Put the three together and you do not get a bigger prompt. You get a pipeline — the way real engineering has always worked, finally available to AI. An idea becomes a design; a design becomes a contract; a contract becomes controlled batches; batches become code; code becomes a validated commit; and validated commits become software you can actually trust. Run it end to end.
I believe this is the real shape of the next decade of software. Not one model that does everything in one shot, but a chain of accountable steps — open, modular, auditable — where intention comes first and proof comes last. The age of prompt-only software is ending. The age of governed AI software creation is beginning.
7 · The invitation
I did not build Matrix Designer to be a product I own. I built it because I wanted the thing I needed to exist in the open — infrastructure that becomes more useful the more people take it apart and improve it. It is the same instinct behind everything I make: that an autonomous system should be accountable for its safety and honest about its costs, and that the best ideas should be the ones you can read, fork, and run yourself.
If you have ever watched an AI produce a beautiful demo and then felt it crumble in your hands, you already know why this matters. Matrix Designer gives the project a brain. Matrix Builder gives the brain a contract. GitPilot gives the contract hands. Together they are a way to build ambitious things with AI without giving up architecture, quality, security, or ownership. The vision, the architecture, and the code are all in the open — and the door is open with them.
See it run
The brain, the contract, and the worker are live and open source — design a project, watch it built under contract, ship it with proof.
▶ Try Matrix, live