Free kit
The prompts you run at a gate, the templates you fill, the guides you read, and the skills that install the method in your assistant.
Everything the method uses, split four ways. Guides are what you read, starting with the core guide and its seven gates. Prompts are what you run at a gate: you paste one into the session and it does that gate's work. Templates are what you fill. Skills install the method in the assistant you already work in.
Each resource says which gate it is used at, and a gate filter sits beside the tabs: set it to one gate and a list narrows to what that gate uses, clear it and everything comes back. The ones that say every gate — the core guide, the control session, the standing constraint, the memory and the journal entries — are the ones you keep going back to the whole way through.
Each one has its own page: a short summary, the complete text, and a Markdown version an assistant can read, under one address and one version. Everything on this page is in the kit as well, so none of it has to be copied back out of a browser.
The whole kit is one download: the core guide, the prompts, the templates, the practice case with its sandbox, the worked example, and both skills. Download the kit
Use it at every gate
/resources/method-guide
The method itself: the seven gates, what each one demands, the prompts it uses, and what you hold before moving on.
/resources/first-case
Start your own project today: one folder, one session opened on it, the first prompt, and the gates that follow.
Use it at every gate
/resources/worked-example
The practice case run end to end, with every artifact filled in and marked as simulated.
/resources/sandbox
A small local application, with no account and no network, to run the practice case against.
Read the core guide end to end once before you point the method at a product. The worked example is the practice case run through the seven gates, with every artifact filled in and marked as simulated.
Use it at gate 0 · Set up the project folder
/resources/prompt-inventory
Converts what it can, indexes every source, lists what it could not read. It interprets nothing.
Use it at gate 1 · Gather the discovery
/resources/prompt-channel-reading
Has an agent read what nobody has time to read. What comes back is input, not a decision.
Use it at gate 2 · Write the PRD
/resources/prompt-prd
Reads what the first two gates left in the folder and writes the PRD into the template.
Use it at gate 3 · Prototype the end-to-end flows
/resources/prompt-design-specification
The long specification the PM session writes for the design tool, demanding end-to-end flows.
Use it at gate 3 · Prototype the end-to-end flows
/resources/prompt-design-instruction
The short layer typed into the design tool alongside the specification and the attachments.
Use it at gate 3 · Prototype the end-to-end flows
/resources/prompt-refinement
For when the first output is too shallow, too conceptual or too dashboard-like.
Use it at gate 4 · Port the prototype into code
/resources/prompt-port
Hands the prototype and the starter to the coding agent, inside your organization's conventions.
Use it at gate 5 · Connect the backend
/resources/prompt-connect
The longest gate: the flows have to hold in depth, not on the surface.
Use it at gate 6 · Test, then ship
/resources/prompt-release
What was tested, by whom, with which accounts, what is known to be broken, what the leads are asked to approve.
Use it at every gate
/resources/prompt-control-session
The second session, the one that challenges. It reads, checks and challenges; it changes nothing.
Use it at every gate
/resources/prompt-standing-constraint
Carry it in every prompt that changes code: memory, journal, and where the work stands.
Two of them are not tied to one gate. The control session runs beside the main one from the discovery to the backend, and the standing constraint travels inside every prompt that changes code.
Use it at gate 2 · Write the PRD
/resources/prd-template
The one template the method fills. Every gate after the second one reads it.
Use it at every gate
/resources/memory-entry
One entry of the memory: where the product stands, and why it moved that way.
Use it at every gate
/resources/journal-entry
One entry of the journal: dated, never rewritten, including what turned out to be wrong.
The PRD template is the one document the method fills: Gate 2 writes it, and every gate after that reads it. The other two are entry formats you copy — one for a decision, one for what happened.
/onirion.claude/skills/onirion/, run bash onirion/claude/install.sh /absolute/path/to/your-project.$onirion.agents/skills/onirion/, run python3 onirion/codex/build_skill.py, then python3 onirion/codex/install.py --project /path/to/your-project (or --user).Both skills carry the same method. They make the session say which gate it is at, what it has in hand, what is missing and what you must decide before it crosses — and they stop there rather than invent a decision, an approval or a service.
Neither adapter changes the method: the gates, what each one demands and what ends it are the same whatever assistant you use. What neither one carries is the wiring — how the main session and the control session address each other inside a given tool is something you set up in that tool.
| What you set up | With Claude Code | With Codex |
|---|---|---|
| Install the method | Run the installer on your folder; the skill lands under .claude/skills/. | Build the skill, then install it into the folder's .agents/skills/, or into your own Codex skills. |
| Invoke it | /onirion, or ask for the method by name. | $onirion, or describe the task and let it match. |
| Run the control session | A second session opened on the same folder, started with the control session prompt and its rules block. | A second session opened on the same folder, started with the same prompt and the same rules block. |
| Move at Gate 4 | Install again on the repository once it exists beside the folder of sources. | Install again on the repository, or install into your own Codex skills so it follows you. |
Installing changes nothing in the rest of your project and starts no product project. Both installers refuse to overwrite a skill that is already there, so an older installation is yours to read and remove before you replace it.
Reuse terms
Text (the method, the guides, the prompts, the templates, the practice case, the worked example, and site pages) under Creative Commons Attribution 4.0 (CC BY 4.0), crediting “Onirion, a method by Alexis Boyer” (with the method's name once chosen); code (the installers, the Codex bundler, the sandbox application and its tests, and the skill files) under the MIT License. Filled-in templates belong to whoever fills them, with no credit needed. Images are not covered by these licenses.