The Constitution File: How I Run a One-Person Software Company with an AI Agent Team

I run more than one software product. I have no employees. What I have is a team of AI agents — one that does marketing, one that does revenue analysis, one that does engineering per project, one that acts as chief of staff — and a single file that all of them read before they do anything: a constitution.

Not a metaphor. An actual CLAUDE.md file, checked into git, that every agent reads at the start of every session, and that overrides anything a project-level file tells them to do.

The problem nobody tells you about when you go from "prompting" to "autonomous agents"

The first few weeks of using Claude Code (or Cursor, or any agentic coding tool) feel like magic. You describe a feature, it ships. Then you give it more autonomy — let it run in the background, let it manage its own todo list, let it work across sessions — and a different feeling shows up: you stop knowing what it's about to do.

Three failure modes show up, in this order, for almost everyone who scales past "one agent, one session":

1. The agent forgets why. It re-litigates a decision you already made last week, because nothing

persisted the reasoning — only the code changed, not the "why."

1. The agent gets close to something irreversible. A force-push, a production deploy, an email to

a real customer, a price change — and there was no gate that made it stop and ask.

1. You can't tell, at a glance, what's actually blocked on you. Ten background agents, ten

half-finished threads, and no single place that says "these three things need your decision."

None of these are model problems. They're governance problems. And governance is not something you prompt your way out of — you have to build it as a system, the same way you'd build permissions and audit logs for a team of human employees.

What a constitution file actually does

The core idea: separate judgment (the agent decides how) from authority (a fixed, short list of actions that always stop and wait for you, no matter which agent, which project, or how confident the agent is). Things like: spending money, emailing an external party, deploying to production, deleting data, committing to a price or deadline with a client, publishing public content.

Everything else — reading, analyzing, drafting, opening a PR, writing tests — happens autonomously. The agent never merges to main. Ever. That's not a prompt instruction; it's enforced at the branch protection layer, so it's not "the agent chose to be careful" — it's "it is physically impossible for the agent to reach production without a click from you."

On top of that: a memory protocol (every agent writes what it did, what it learned, and what's still open, before it finishes — so the next session doesn't start from zero), budget envelopes (an agent with money to spend gets a pre-approved envelope and a ledger, never a blank check), and kill/scale criteria per project (every project has a written definition of "when we stop" before it starts — so shutting something down is a criterion check, not a hard emotional call).

Why this compounds

The unlock isn't any single rule. It's that the system is the same file across every project and every agent. A new project doesn't get a bespoke process — it inherits the constitution, gets a registry entry, a status file, a memory file, and it's instantly running on the same rails as everything else. Adding a tenth product costs almost nothing extra in oversight, because the oversight was never per-product to begin with.

That's the actual test of whether a governance system works: does the founder-hours cost of running project #5 look like the cost of running project #1? If yes, you built infrastructure. If no, you built a one-off habit that won't survive contact with a second product.

---

This is the exact system, extracted and packaged, that I use to run my own products. If you're past the "one agent, one session" stage and starting to feel the "wait, what did it just do" anxiety — [link to landing page].

image/asset ideas for the post

• Header: a single markdown file (CLAUDE.md) rendered next to a "team" of small agent icons all

pointing to it — visual metaphor for "one source of truth."

• Inline diagram: the three failure modes as a simple before/after (agent → wall → founder decision).