The problem
Building solo is manageable. Bigger projects are not. When I started coordinating AI agents for more complex work, I hit the same wall every time: without clear decision rights, scope debates never ended. One agent would start building while another assumed we were still in design. No escalation path. No clear lanes. Multi-agent systems need rules, not just good intentions.
The approach
I drafted a Constitution — literally, like a governing document. Each of the 15 roles has explicit domain boundaries: Dani owns design, Steve owns security, Rory owns deployment. Morgan (the PM) routes decisions to the right domain instead of letting them pile up. My role is final call on trade-offs, nothing else.
The system is strict by design — agents can’t self-approve major decisions. That sounds heavyweight, but written rules actually freed everyone. When you know your lane, you can move fast inside it. I came to think of governance as infrastructure: code needs architecture, teams need constitutions.
What shipped
A 15-role AI team governed by a written Constitution, with an orchestrator that runs cycles and routes work. Each role has its own command file, a defined scope, and a QA report trail. This portfolio — the one you’re reading — was built and maintained entirely within Claude Corp. The Constitution is a working document, not a published one — it changes when the system finds a new failure mode.
My role
Mine. The design, and specifically the parts that remove discretion. Sessions die mid-task and lose their place. Agents overstate what they finished. A stray instruction sitting in a file an agent reads can try to redirect it. Each of those got a rule rather than a habit. The authority order settles any conflict — my intent, then the Constitution, then role files, then skills — and no agent may amend the Constitution to win one. One role may message me; the other fourteen write to files I read on my own schedule. Recovery resumes from the last checkpoint instead of restarting, and gives up after three attempts on the same node instead of looping. The flexible version — let each agent judge when to escalate — is the one I rejected every time, because judgement is the thing I cannot verify at scale.
What it does without me. Before starting, a role scans for another agent’s open branch or a fix already shipped, and writes a conflict report instead of duplicating the work. It caught a session that reported pushing a commit to a main that was still three commits behind — the claim was confident and wrong, and reconciliation, not trust, is what found it.
What I check. The escalations, and the reports of work not done. A system that only ever tells me it succeeded is one I have no way to audit.
Reflection
The biggest unlock wasn’t any individual role — it was realizing that the rules are what make speed possible.
I’d build the governance layer first next time, before writing a single line of application code.
