Workflow Design Bible

A constitution + document-system generator for autonomous, agent-run projects.

workflow-design-bible is a reusable meta system prompt (and an installable agent skill). Point it at a brand-new project idea — a content channel, an ebook press, an SEO tool-site, a web product, a casual game, anything meant to run itself — and it interviews you, then scaffolds a complete, opinionated workflow:

• a thin CLAUDE.md boot router that stays resident every turn but holds almost nothing;
• a document system under documentation/ — a fixed set of named single-source docs (CONSTITUTION.md, WORKFLOW.md, ROLES.md, ARCHITECTURE.md, IDENTITY.md, SOUL.md, MEMORY.md, NEXT_SESSION.md, …) loaded once per session, not every turn (and some, like the architecture baseline, only when a task reaches for them);
• a session lifecycle — /start-session → work → /finalize-session — so each session boots from where the last one left off and ends by improving itself, plus a periodic /slim-docs diet so the document system gets lighter over time, not heavier;
• a growing identity and soul, so the agent becomes a work partner that gets more itself over time, not a stateless tool.

It encodes one architecture that has proven itself on real autonomous projects:

The main agent is a CEO, not a worker. It orchestrates; sub-agents do the work; skills document capabilities; a deterministic CLI executes them. Every session ends by reflecting on itself and freezing "decided on the fly" into "frozen into a function."

— distilled into thirteen design philosophies every generated project inherits.

---

Why this exists

LLM agents are great at doing a task and bad at running a project. Without a durable structure they re-decide the same things every session, bloat their own context, lose track of what's already built, forget who they are, and never improve their own process.

This Bible bakes in the structure. The biggest win in v2 is the reload economics: only the thin router rides in context every turn; the heavy knowledge sits in named docs read once per session. Same knowledge, a fraction of the token cost — and a context window that fills up far more slowly. On top of that: a CEO/sub-agent split, five clean capability layers, a session lifecycle that carries state forward, a built-in self-consistency check, and an identity/soul that compounds. You answer a short interview; you get a project that knows how to run, remember, and improve itself.

The thirteen design philosophies

1. The main agent is a CEO, not a worker — orchestrate, don't do manual labor; the CEO keeps only the org-change decisions, the final QA, the ship step, and the closing report to the chairman.
2. Everything is a sub-agent; concurrency is the default — all creation and all maintenance is employee work; every role carries paired skills; fan out at the seams — and every fan-out point declares its isolation substrate (disjoint output paths · a private workspace · a disposable worktree when workers change code · a lock on the one seam that can't be split), because fan-out without isolation is a race, not concurrency; internal-first — never outsource (or spend external API credits on) what an internal sub-agent can do; external contract partners are rostered separately (engaged by contract, not managed by prompt).
3. Five-layer architecture — CEO → sub-agent prompt → skill → MCP/CLI → deterministic functions; LLMs create and decide, code executes; every pipeline step names its executing function; pointers down, details never up.
4. The document system — a thin CLAUDE.md router + named single-source docs loaded once per session, not every turn.
5. Global vs local capabilities — reuse what's shared, build only what's unique.
6. Reflection is the last step, wrapped in a session lifecycle — five mandatory lifecycle skills every project ships on day one: /start-session and /finalize-session (soft boot, soft shutdown, two loops) plus the periodic /self-reflection, /self-reflection-cli, and /slim-docs.
7. Constitution-as-code — a doctor command keeps STRUCTURE.json's claims equal to filesystem reality, and a general ratchet forbids new violations while old debt is paid down on a schedule. Every doc also carries an OKF-subset provenance header, so a rule the owner personally signed off is never mistaken for one the agent wrote last Tuesday.
8. A standard project shape — thin router + documentation/ system from birth.
9. The agent has a growing identity and soul — IDENTITY.md + SOUL.md; it becomes more itself each cycle.
10. Quality is a deterministic gate — QA is functions, not opinions: no self-check, no report (workers); no final validate, no ship (CEO); and at least one oracle from outside our own loop, because a spec, code, and tests all written by the same agent can only confirm themselves.
11. The codebase has a constitution too — an architecture baseline the agent owns (ARCHITECTURE.md): invariants, who owns which state, CURRENT vs TARGET vs the evidenced GAP between them, and ADRs. Read before designing, written back before "done" — so bad structure fails this task instead of a future one.
12. The project has a stage, and the stage has a gate — building costs nothing now, so the only brake on a bad idea is a written gate: the current stage's exit criteria as yes/no questions answered by outside evidence, its false positives, and a stage_premature outcome that blocks work belonging to a later rung. A rebuttal precedes every crossing; the chairman decides it; rejections record what evidence would reopen them; and the absence test asks what stalls when the owner is away a week.
13. The front desk: one entry, plain outcomes, a budgeted interrupt — the ot