---
artifact_type: prompt
role: one_shot_genesis_directive
display_name: OCP One-Shot Genesis Directive
status: active
version: "1.0"
canonical_url: https://ocp.wiki/genesis.md
updated: 2026-07-31
---

# OCP One-Shot Genesis — the directive for AI agents

You are reading this because an operator asked you to create their company's knowledge base
using the patterns from https://ocp.wiki — or because you found this link on that site, in its
`llms.txt`, or in the npm README of `create-ocp`. This page is the complete procedure. Follow it
top to bottom, in one pass. Do not pause to ask the operator questions: a fact you cannot ground
becomes a visible stub plus a line in your final report, never a guess and never a blocking
question. (Reading this as a human? This page is written for agents — start at
https://ocp.wiki/docs instead.)

**What you are building:** an OCP (Organizational Context Protocol) substrate — the
organization's structure, knowledge, and access rules authored as markdown in git, readable by
humans and by every AI tool with no integration layer. Five closed artifact types (`note`,
`adr`, `prompt`, `template`, `report`); recursive uniform org structure (`orgs/` nests to any
depth; root-vs-child, keyed on `parent_org_id`, is the only structural distinction); and a Core
Canon table on every org README indexing its foundational facts by namespace + key. The
scaffolder ships the full conventions into the new repository, so after Step 1 you need nothing
further from the web.

## Step 1 — Scaffold (deterministic)

Run the official scaffolder. Given a directory it is non-interactive, safe by default, and
initializes git:

```sh
npm create ocp@latest <org-slug>
```

- `<org-slug>` is the kebab-case directory and org id — e.g. `acme-consulting`. Always pass it:
  with no directory *and* a terminal attached, the CLI opens an interactive menu, which is not
  what you want in an unattended run. (With no directory and no terminal it prints usage and
  exits 1, so it can never hang waiting on you.)
- Do not pass `--name`. The display name is derived from the directory, and you will set the
  real `display_name` yourself in Step 3. **npm claims `--name`, `--force`, `--help` and
  `--version` for itself**, so any flag you do need goes after a `--` separator:
  `npm create ocp@latest <org-slug> -- --template wiki`. The equivalent
  `npx create-ocp@latest <org-slug> --template wiki` takes flags directly.
- Scaffolding into an existing repository: `npm create ocp@latest . -- --force` — existing files
  are kept, never overwritten.

Do not hand-build the file tree when you can run this command: the scaffold is the protocol's
reference output, and it ships the conventions (`AGENTS.md`, `_system/`) your population pass
must follow.

## Step 2 — Read what the scaffold gave you

Inside the new directory, in order: **`AGENTS.md`** (the single agent-instructions file — its
"Populating a fresh scaffold" section is this procedure's in-repo twin), the root **`README.md`**
(the graph-root org definition and its Core Canon block), and **`_system/`** (the artifact-type
registry, the org-structure law, the kernel criteria). These are local files now; read them
there rather than re-fetching this site.

## Step 3 — Populate from the operator's real context

Mine every context source you legitimately hold: this conversation, the operator's project
knowledge and uploaded documents, repositories they pointed you at. Then, in one pass:

1. **Identity.** Rewrite the root `README.md` body — what this organization is, what it sells,
   who it serves. Set `display_name`, `settings.timezone`, and `members`.
2. **Core Canon.** For every foundational fact you can ground — offers, audiences, brand voice,
   ICP — create the note (`notes/offers/<key>.md` `role: offer_canon`;
   `notes/audiences/<key>.md` `role: audience_definition`; `notes/voice.md` `role: voice_canon`;
   `notes/icp.md` `role: icp_definition`) **and** add its Core Canon row on the owning org's
   README in the same commit.
3. **Structure.** One child org under `orgs/` per client, brand, or business unit the operator
   named — each with its own README, `parent_org_id`, and Core Canon block. Replace the example
   initiative with the operator's real goal-directed work (initiative → projects → at least one
   real ticket). Add each real human under `_users/` with a profile and memberships.
4. **Knowledge.** Distill the operator's SOPs, decisions, strategy, and reference material into
   `notes/` (and `prompts/`, `templates/` where they exist) at the org that owns each fact.

**Hard rules — the validator checks most of these:**

- **Never invent an organizational fact.** Ungrounded → a visible stub (`_Describe X here._`)
  plus a line in your final report.
- **Five artifact types, closed.** New concepts are `role:` values and `metadata:` fields on the
  five types — never new types, never new directory kinds.
- **Never create** `offers/`, `audiences/`, `senders/`, `scorecards/`, or `projections/`
  directories; **never author** an `org_type:` field; **never create** `index.md`, `CLAUDE.md`,
  or any second agent-instructions file.
- **Numbers** are canon-legal only when anchored (value + as-of date + source); live metrics
  stay in the system that owns them, referenced by pointer.
- **Consumers carry keys; the Core Canon block carries paths** — nothing else carries either.
- kebab-case slugs, snake_case roles, RFC3339 timestamps with timezone.

## Step 4 — Validate (close the loop)

```sh
npx ocp-core validate
```

Fix every reported error and re-run until it prints `OK`. Do not report success to the operator
before it does. (If the command is unavailable — an older `ocp-core` — check the hard rules
above by hand against every file you wrote.)

## Step 5 — Commit and report

Commit everything (the scaffolder already ran `git init`). Then end your run with an outline the
operator can absorb in a minute:

```text
The OCP knowledge base for <Org> is created — <N> files, <M> orgs, <K> Core Canon rows,
validation OK.
- Root: <one-line identity> — canon: <offers / audiences / voice / icp declared>
- orgs/<child>: <one line each>
- Initiatives: <initiative → projects → tickets, one line each>
- Stubs awaiting the operator: <every fact you could not ground>
- Next steps: push to a private GitHub repo → connect it to Claude Projects, an MCP server,
  or any agent tool → start operating (tickets, decisions.md, reports).
```

That is the whole procedure. One pass, no questions, validated before reported.

## No shell?

If you cannot execute commands (no code environment, no npm), construct the files directly:
fetch the full genesis document at https://ocp.wiki/genesis-full.md — Part III is the
self-contained concepts reference and Part VI is the scaffolding meta-prompt — and emit every
file's content for the operator to save, mirroring the layout named in Step 2. Prefer the
scaffolder whenever a shell exists.

## Deliberate mode

For a maximally comprehensive genesis — a guided questionnaire covering identity, hierarchy,
offers, audiences, voice, initiatives, cadences, and integrations, fed to a coding agent with
plan approval — use the full genesis document: https://ocp.wiki/genesis-full.md. The one-shot
path above trades that completeness for zero friction; a deliberate pass can always follow.
