From Idea to Production: The Nine-Article Map of an AI Delivery Org
Series: Idea-to-Production · Series summary. Companion pieces in the series: “Human Out of the Loop” (the concept), “Thirteen Stages and Their Artifacts” (the mechanics), and “Documents as Executable Assets” (the methodology).
“A human provides an idea. AI delivers the product. No human is in the loop.” After nine articles, the concept tends to dissolve into fragments in the reader’s head. This page does exactly one job: compress that sentence, word by word, into one closed-loop map of concept → mechanism → methodology — every article in its place, each supporting the others. Want to go deeper into one layer? Follow the map.
Why this page exists
The question “can AI build a product on its own” usually stops at the feeling level — “mostly automatic,” with “a human kept at the critical points.” This series answers the opposite: no human in the loop — and then writes that sentence down as a checkable contract, held up by engineering discipline.
The nine articles each drill into the contract, the machinery, or the methodology in depth. The cost of that depth: the panorama is easy to lose. This page repeats none of the individual arguments; it delivers two things only — one checkable core concept, and a closed-loop map that answers “which article solves which problem.”
Three things you’ll take away
- “A human provides an idea, AI delivers the product, no human is in the loop” is a checkable contract, not a percentage-flavored slogan: four claims, each of which forces specific machinery to exist.
- The concept, mechanism, and methodology tiers form a closed loop: concept defines the contract, mechanism fulfills it, methodology keeps it from rotting — drop one tier and the other two cannot hold.
- Each of the nine articles has exactly one job: enter from your current problem (what is it / how does it run / what does it believe) — no need to read them in sequence.
The core concept: one sentence, four claims
The entire series says one sentence:
A human provides an idea. AI delivers the product. No human is in the loop.
Every word is taken literally: A human provides an idea — the human performs exactly one action (create the project, write the idea) and then never appears in the delivery path again; AI delivers the product — requirements, design, implementation, tests, release, and operations are all carried out by a team of AI role agents, straight to production; no human is in the loop — there is no manual step inside the delivery loop: no approval gates, no “human check at the critical points,” never blocking on a human.
It sounds like a slogan, so it is broken into four falsifiable claims — which is also the precise meaning of the term “human out of the loop”:
| Claim | What it forbids |
|---|---|
| One action starts everything | “The human still writes the first task” — the moment a project is created, the kickoff task is auto-generated; after that, every task is authored, dispatched, claimed, executed, and reviewed by agents |
| No approval gates | PRD sign-offs, release go/no-go, manual rollback decisions — quality can only be enforced by machine gates |
| Never blocks on humans | Treating the notification channel as an approval — notifications are an escalation path: record and proceed or stop cleanly, never wait for a reply |
| Human works on the system, not in it | Per-task human braking — the human’s recurring job is meta-review: read the governance report, improve the system itself |
It is also explicitly three things it is not: not a chatbot, not a code generator, not a human-watched assembly line. It is an autonomous delivery organization — org chart, runbooks, and audit trail all live in git.
For the full argument behind the four claims and the five prohibitions, see the series’ first article, “Human Out of the Loop: The Concept Contract of an Autonomous Delivery Organization.”
The system map: concept → mechanism → methodology
Concept tier A: what it is, why it holds
four claims ─ three-repo split ─ nine-role org chart
│
▼
Mechanism tier B: how it actually runs
per-stage artifact contracts ─ three scheduling machines ─ recurring loops
│
▼
Methodology tier C: what it believes
docs as executable ─ human meta-review ─ production walkthrough
│
▼
idea in (the human's one action) → product out to production (no human in the loop)
The nine articles, one line each — the title is the entry point:
| Tier | Article | One-line position |
|---|---|---|
| Concept | Human Out of the Loop: The Concept Contract of an Autonomous Delivery Organization | Four claims + five prohibitions: “human out of the loop” written as a checkable contract |
| Concept | Why Split Into Three Repositories: The Separation Law of Knowledge, Dispatch, and Archive | Split by speed of change and ownership; mixed layers are why most agent frameworks stop evolving |
| Concept | How Nine Roles Split a Whole Company: An Agent Org Chart That Never Drifts | Nine roles = nine blocks of decision ownership + artifact ownership + recurring loops |
| Mechanism | Thirteen Stages and Their Artifacts: The Type System Between Agents | What each stage consumes and produces — every hand-off is typed |
| Mechanism | Three Mechanisms of Unattended Scheduling: Claim Locks, Central Push, Idempotency Keys | One task one worker, center-owned scheduling, re-runs that never double work |
| Mechanism | How the System Stays Alive After Launch: The Catalog and Design of Recurring Loops | Eight recurring loops keep the system alive after launch; failures don’t break the chain |
| Methodology | Documents as Executable Assets: When Agents Consume Your Specs Verbatim | Ambiguity is a production defect; a TODO is runnable dead code |
| Methodology | Humans Above the System: The Weekly Governance Report and Meta-Review Practice | The human’s job upgrades from “reviewing tasks” to “reviewing the system” |
| Methodology | One Idea In, One Product Out: A Full Software Company Run by Nine Classes of AI Agents | Full walkthrough: one idea travels the entire pipeline to production |
How the three tiers interlock
Any layer on the map could be built alone. What actually meshes them are four invariants — they recur across all nine articles and are collected here:
- Every human gate removed must regrow as a machine gate. Per-deliverable review, the integration-surface review gate, and end-to-end tests are the contract’s price tag; cut them and autonomy merely scales errors at machine speed.
- Recurrence is always owned by the center. Roles may be multi-instance, but the trigger belongs only to the scheduler — whoever self-schedules duplicates output.
- Documents are executable assets, not reference material. Downstream agents execute them verbatim: ambiguity is implemented literally, placeholders genuinely run.
- Humans change the level of intervention, never just the amount. You read reports, not requests; you produce system improvements, not task approvals.
How to use this series
The nine articles stand alone; no need to read them in order. Enter from your current problem:
- “What is it, and why does it hold?” → the three concept articles, starting with Human Out of the Loop: The Concept Contract of an Autonomous Delivery Organization.
- “How does it actually run?” → the three mechanism articles, starting with Thirteen Stages and Their Artifacts: The Type System Between Agents; for scheduling details see Three Mechanisms of Unattended Scheduling: Claim Locks, Central Push, Idempotency Keys.
- “What does it believe?” → Documents as Executable Assets and Humans Above the System, then close with One Idea In, One Product Out to run one idea through the whole pipeline.
Whichever layer interests you, the titles in the table above are the entry points: all nine articles are published — missed or skipped one? Catch up by title, since every article in this series is searchable by its title.
CeXia: the working implementation
CeXia (策匣) is this method, running: create a project, write the idea, and nine AI role agents take it from there — all the way to production, with no human in the loop. App intro: https://github.com/KylinLabAI/CeXia-App.
Scope guardrail
This page is only a concept map and reading guide. Deliberately out of scope: model selection and pricing, prompt techniques, cost engineering, and concrete deployment/operations runbooks — those are separate topics, not covered by this series.
Summary
- “A human provides an idea, AI delivers the product, no human is in the loop” is a checkable contract — one action starts everything, no approval gates, never blocks on humans, human above the system: each of the four claims has machinery behind it.
- The three-tier loop is inseparable: concept defines the contract, mechanism fulfills it, methodology keeps it from rotting — nine articles, each in its place.
- Start from the layer you lack most: no need to read all nine — use the map to find the entry point for your current problem.
The concept is now laid out. The smallest first step: find the stretch in your own system that is “waiting for a human’s reply right now,” write it up as a claim — then follow the map to whichever article is exactly about it.