Free to use
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.
Guides are what you read, prompts what you run at a gate, templates what you fill, and skills install the method in the assistant you already work in. Each one says which gate it is used at, and the filter beside the tabs narrows the list to that gate.
Everything here also travels inside the project folder you download to start a case, so an assistant reads it from your own disk. Download the project folder
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 4 · Port the prototype into code
/resources/prompt-observed-conventions
When the backend has code but no written conventions: the agent describes the ones the code already follows, and the backend owner confirms, corrects or rules them out.
Use it at gate 4 · Port the prototype into code
/resources/prompt-backend-requests
While the port runs: the agent lists what the backend work will need from other teams — access, permissions, keys, resources — as requests to send now, not on the day you are blocked.
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 where the version offers it.claude/skills/.claude/skills/onirion/. To carry it into another project, copy .claude and .agents across.$onirion where the version offers it.agents/skills/.agents/skills/onirion/. Copy that folder into $CODEX_HOME/skills/ to have it everywhere.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 | Nothing to install: it is in the project folder you download, under .claude/skills/. | Nothing to install: it is in the same folder, under .agents/skills/. |
| Invoke it | Ask for the method by name. /onirion is a shortcut where the version offers it. | Describe the task and let it match. $onirion is a shortcut where the version offers it. |
| 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 | Copy .claude and .agents into the repository once it exists beside the folder of sources. | Copy the same two folders across, or put the skill in 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
The method is free to reuse. The core guide, the prompts, the templates, the practice case and the worked example are under Creative Commons Attribution 4.0 (CC BY 4.0), crediting “Onirion, a method by Alexis Boyer”; the code — the sandbox application and its tests, and the skill files — is under the MIT License. Filled-in templates belong to whoever fills them, with no credit needed.
The pages of this site are not. They are © Alexis Boyer, all rights reserved: use the method in your own work as much as you like, but do not republish these pages, in whole or in part, without asking. Images are not covered by any of the above.