I Replaced My Prompt Pile with a Constitution: Organizing AI Coding Agents into a 16-Role Company

Empire Iron Corps — Wed, 14 Oct 2026 11:24:47 +0000

Like a lot of you, I started with one AI coding agent and a growing pile of prompts. Every incident produced a new patch: "when you do X, remember Y." Within a few months the pile was unreadable, the agent ignored half of it, and I still had to re-explain the same decisions every session.

The turning point wasn't a better model. It was a different question. Instead of asking "what prompt fixes this?" I started asking "who owns this decision?"

1. Personality stickers vs. enforceable charters

Most "AI team" templates you find are personality stickers: "You are Alice, a senior engineer who loves clean code." Fun, but not load-bearing.

What actually changed my agent's behavior was writing charters instead of personas. Every role in my setup has a document that specifies:

Mission — what this role is for, in one sentence
Decision framework — the procedure it must follow before acting (e.g. "any 'should we build X?' passes five questions: why fight it, do we have ammunition, how do we retreat, can we hold the ground, who executes")
Collaboration protocol — what it must accept from other roles (a risk officer's veto is non-negotiable; bad news travels up unfiltered)
Hard boundaries — lines it cannot cross even when the user asks (spam, fake engagement, fear-selling)
Output standard — what its deliverable must look like (every claim graded by evidence level; "no verification run, no 'done'")

The persona is three lines of flavor. The charter is the actual operating system.

2. The org chart (16 roles, no humans in the loop except decisions)

The structure that emerged:

A CEO-role agent that owns strategy and arbitration (one decision framework, applied everywhere: five questions before any battle)
Eight staff officers: chief of staff (sequencing), intel (recon & evidence grading), product (acceptance criteria), engineering (implementation & verification), growth (distribution), risk (independent veto power), opportunity (unit economics), foresight (long-range bets)
Content legions (writing / short-video / short-drama) with an independent review corps — three reviewer seats that are structurally forbidden from reporting to the production chain. No review, no ship.
A standing scout mechanism that continuously reconnoiters open-source practices and absorbs them (evaluate → trial → adopt → review)

The role I didn't expect to matter most: the risk officer. Agents don't have self-preservation instincts, but they do have drift. A role whose entire charter is "say no, then justify" catches the drift early.

3. The ten rules that survived contact with reality

The full set ships in the pack, but three proved load-bearing:

Evidence before claims. No "should work." If the verification command didn't run, the task isn't done. Every claim is graded: machine-level proof, behavior-level proof, or consensus of independent checks.
One battle at a time. Parallelism is for independent tasks with disjoint writes — never for three half-wars. Priority conflicts get arbitrated, not raced.
A shared battle log is the memory. Every action appends ≤3 lines (decision + reason, or failure + root cause + fix) to one log file. The next session starts from the log and never asks a human to re-explain context.

That last one quietly killed my biggest time sink: context re-explaining. The log is the handover document.

4. Accountability without bureaucracy

The piece people assume must be heavy: process. It isn't, because the process is enforced by other agents, not by meetings:

The review corps grades every deliverable; under threshold = automatic rework, no debate
Failures trigger a four-step root-cause investigation; the same root cause twice = process blame, not bad luck
Any "done" without a verification trail is treated as not-done by the next shift

The overhead is a few hundred lines of markdown. The saving is measured in not-re-doing things.

5. What I'd tell my past self

Stop collecting prompts; start writing charters with explicit decision frameworks
Give one role veto power and protect its independence structurally
Write the shared log format first — it's the real memory of the team
Keep hard boundaries even when it's inconvenient; they're what makes delegation safe

6. The pack (free & open)

I packaged the whole thing as Empire Iron Corps — 22 charters, ten rules of engagement, five working templates, a knowledge-graph methodology for keeping lessons, and three zero-dependency verification scripts (pack integrity + assembly check + wording lint).

Repo: https://github.com/yyyz1yyyz2/empire-iron-corps
Landing page with downloads: https://empire-iron-corps.vercel.app
License: docs CC BY 4.0, code MIT

Honest notes: the charters are written in Chinese (an English edition is on the roadmap); all 16 member names and backstories are explicitly fictional AI personas — they exist to constrain behavior, never to be passed off as real credentials; and the pack shares an organizational paradigm, with no income claims attached.

If you've solved the "many agents, no accountability" problem differently, I'd genuinely like to hear how — charters plus a shared battle log is my current answer, and I assume it's not the only one.

Disclosure: this is my own open-source project; nothing here is paid promotion.