---
title: Resources
route: /resources
lang: en
part_of: Onirion
version: "4.0"
date: 2026-09-22
author: Alexis Boyer
license: CC BY 4.0
one_line: "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."
layers:
  summary: /resources
  complete_text: /complete.md
  markdown: /resources.md
---

# Resources

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](/downloads/onirion-4.0.zip)

## Guides

- [Core guide](/resources/method-guide) — The method itself: the seven gates, what each one demands, the prompts it uses, and what you hold before moving on. Use it at every gate. Markdown: [/resources/method-guide.md](/resources/method-guide.md)
- [Start a case](/resources/first-case) — Start your own project today: one folder, one session opened on it, the first prompt, and the gates that follow. Markdown: [/resources/first-case.md](/resources/first-case.md)
- [Worked example](/resources/worked-example) — The practice case run end to end, with every artifact filled in and marked as simulated. Use it at every gate. Markdown: [/resources/worked-example.md](/resources/worked-example.md)
- [Practice sandbox](/resources/sandbox) — A small local application, with no account and no network, to run the practice case against. Markdown: [/resources/sandbox.md](/resources/sandbox.md)

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.

## Prompts

- [Inventory and convert](/resources/prompt-inventory) — Converts what it can, indexes every source, lists what it could not read. It interprets nothing. Use it at gate 0 · Set up the project folder. Markdown: [/resources/prompt-inventory.md](/resources/prompt-inventory.md)
- [Read the channels](/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 1 · Gather the discovery. Markdown: [/resources/prompt-channel-reading.md](/resources/prompt-channel-reading.md)
- [Analyse and 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 2 · Write the PRD. Markdown: [/resources/prompt-prd.md](/resources/prompt-prd.md)
- [Design prompt — specification](/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. Markdown: [/resources/prompt-design-specification.md](/resources/prompt-design-specification.md)
- [Design prompt — instruction](/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. Markdown: [/resources/prompt-design-instruction.md](/resources/prompt-design-instruction.md)
- [Refinement prompt](/resources/prompt-refinement) — For when the first output is too shallow, too conceptual or too dashboard-like. Use it at gate 3 · Prototype the end-to-end flows. Markdown: [/resources/prompt-refinement.md](/resources/prompt-refinement.md)
- [Port the prototype](/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. Markdown: [/resources/prompt-port.md](/resources/prompt-port.md)
- [Connect the backend](/resources/prompt-connect) — The longest gate: the flows have to hold in depth, not on the surface. Use it at gate 5 · Connect the backend. Markdown: [/resources/prompt-connect.md](/resources/prompt-connect.md)
- [Prepare a release](/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 gate 6 · Test, then ship. Markdown: [/resources/prompt-release.md](/resources/prompt-release.md)
- [Control session](/resources/prompt-control-session) — The second session, the one that challenges. It reads, checks and challenges; it changes nothing. Use it at every gate. Markdown: [/resources/prompt-control-session.md](/resources/prompt-control-session.md)
- [Standing constraint](/resources/prompt-standing-constraint) — Carry it in every prompt that changes code: memory, journal, and where the work stands. Use it at every gate. Markdown: [/resources/prompt-standing-constraint.md](/resources/prompt-standing-constraint.md)

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.

## Templates

- [PRD template](/resources/prd-template) — The one template the method fills. Every gate after the second one reads it. Use it at gate 2 · Write the PRD. Markdown: [/resources/prd-template.md](/resources/prd-template.md)
- [Project memory — entry](/resources/memory-entry) — One entry of the memory: where the product stands, and why it moved that way. Use it at every gate. Markdown: [/resources/memory-entry.md](/resources/memory-entry.md)
- [Project journal — entry](/resources/journal-entry) — One entry of the journal: dated, never rewritten, including what turned out to be wrong. Use it at every gate. Markdown: [/resources/journal-entry.md](/resources/journal-entry.md)

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.

## Skills

### Claude Code skill

- Invoked as: `/onirion`
- Installs into: `.claude/skills/`
- Includes: The core guide, the prompts and the templates, bundled into the installed skill so it reads nothing from the kit afterwards.
- Install: Download and unzip the kit, then, from the folder that contains `onirion/`, run `bash onirion/claude/install.sh /absolute/path/to/your-project`.

[Install instructions](/resources/claude-code-skill#adapter) [Download the kit](/downloads/onirion-4.0.zip)

### Codex skill

- Invoked as: `$onirion`
- Installs into: `.agents/skills/`
- Includes: The core guide, the prompts and the templates. Installs into the project folder, or into your own Codex skills.
- Install: Download and unzip the kit, then, from the folder that contains `onirion/`, run `python3 onirion/codex/build_skill.py`, then `python3 onirion/codex/install.py --project /path/to/your-project` (or `--user`).

[Install instructions](/resources/codex-skill#adapter) [Download the kit](/downloads/onirion-4.0.zip)

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.

[What changes between the two tools →](/resources#tools)

## One method, two execution paths

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](https://creativecommons.org/licenses/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](https://opensource.org/license/mit) License. Filled-in templates belong to whoever fills them, with no credit needed. Images are not covered by these licenses.