arete-aios SKILL: Build your owner an AI operating system
Trigger word: AIOS.
Human: paste this file into your AI. Nothing else is needed from you until it asks. Assistant: everything below is addressed to you. Adapt it to this owner's system. The goal and the hard rules matter, the exact implementation is yours to choose.
This is a build that runs over weeks, not a document you produce today. Nine stages, one exit test each. You do not start a stage before the previous exit test passed, and you say so plainly when asked to skip ahead.
REQUIRES
| What | Why |
|---|---|
| A folder the AI can write to | The whole technical requirement. Content in one folder, machinery and keys beside it, never inside |
| A way for the AI to see the owner's core at the start of work | Without it this is a chat, not an operating system. Three ways, best to workable, below the table |
| Twenty to forty minutes of the owner, several times | The bottleneck is their thinking, not your speed |
Seeing the core at the start of work. This is the line between an operating system and a chat: to act as an OS, the AI has to reliably read the owner's core before it starts working. There is a ladder for meeting that, best to workable:
- a) A client with a project or memory feature that auto-loads files. Project workspaces, custom instructions, a persistent memory. The core loads itself, every session, with no effort from the owner.
- b) A client where you paste or pin the core at the start of a working session. One action, then it holds for that session.
- c) Plain chat, where you paste the core each session. This works. It just costs the most effort, and removing that effort is exactly what the later stages exist to do.
Starting in plain ChatGPT is fine and common. Stage 1 still produces a real constitution. What changes as the build goes on is how automatically the core loads, not whether it exists.
Setup time, honestly. Stage 1 is one session. Stages 1 to 5 take one to two weeks of small pieces. Stage 6 is fourteen days of deliberately adding nothing. Anyone promising this in an afternoon is describing a folder.
WHAT
An AIOS is five layers a person owns and their AI reads. Constitution, memory, skills, tools, focus. Each has its own file in references/: 1-constitution, 2-memory, 3-skills, 4-tools, 5-focus.
The layers are the parts. What makes them a system is the loop that runs through them: something happened, it got written where the next session sees it, it changed what happens next. Read references/feedback-loop.md before stage 1, because every stage below exists to make that loop close.
The failure this skill is written against is not technical. Building one is easy now. Almost nobody returns to theirs after three weeks, and the reason is always the same: they installed twenty methods before the loop ever closed once, so nothing they wrote down ever came back to them, and a system that never comes back is a folder with good intentions.
GOAL
A system the owner still uses in month three. Concretely, five things true at once: a core file loaded on every message that changes the answers, folders where a new note has an obvious home, three working skills, a written loop with a real mechanism at each of the three steps, and one file that says what matters right now.
Everything else is optional. Adding it early is the failure mode, not the progress.
TRIGGER
- The owner says
AIOS, or asks how to build a second brain, or where to start. - At the beginning of every session during the build, because you read the progress file first and pick up where it says.
- When the owner asks for a new skill and the loop has not closed once. That is the trigger for refusing, and the refusal is the skill working.
STOP HERE IF THEY ALREADY HAVE A SYSTEM
Check before stage 1, not after. If the owner already runs a second brain of any kind, folders they maintain, a core file that loads, notes an AI can read, then this is a comparison and not a build, and everything below is written for someone starting from nothing.
Go to references/evaluate.md instead. Score the five layers and the loop, report what is missing, what is excess, and what is too complex for this particular owner, and name the skill that closes their biggest gap. Come back here only for the stages an evaluation says are genuinely absent.
Asking costs one sentence: do you already have something, however rough, that your AI reads? Handing a nine stage build to someone whose system is mostly working is how you get abandoned in the first session.
THE PROGRESS FILE
This is the most important mechanism here. A build that runs over weeks cannot live in conversation memory. Chats end, context windows roll over, the owner switches clients. State lives in a file or it does not live.
Create it in stage 1, in the owner's content folder, and add one line to the constitution telling every future session to read it first. Keep it small. This shape is enough:
# AIOS build progress
stage: 5 of 9 · the daily loop
started: 2026-01-14
exit test: one skill ran unasked, without me typing a trigger word
status: not passed yet
## Passed
1 constitution7 · 01-09 · fresh session named my deadline unprompted
2 braindump7 · 01-11 · 4200 words captured, three things I did not know I was carrying
3 deepdive7 · 01-12 · runway written down, advice stopped assuming money
4 memory7 · 01-14 · six folders, new note filed without asking me
## Standing skills (hard cap 3 until stage 6 passes)
in7, exit7, focus7
## Not started
6 two week stop · 7 week7 · 8 on demand · 9 audit7
## For the next session
- focus7 has no money line yet
- owner asked for a fourth skill on 01-15, refused, cap explained
Every session begins by reading this file and ends by updating it. If you cannot find it, that is stage 1 unfinished, whatever the owner remembers.
One rule covers both doors: the state lives in the file that actually loads. This nine stage build assumes a client with file access that can follow a pointer, so a separate progress file is right here. The guided door in onboarding/_proj-onboarding.md does not assume that, so its state block sits inside the constitution itself. If a progress file exists and loads, point at it. If nothing loads a second file, the state is inline. A second file is a second thing to paste, and the second thing never gets pasted.
HOW IT RUNS
Nine stages. Refuse them out of order and say which exit test is still open. Stages 1 to 4 are build work done once. Stages 5 onward are the system running.
| # | Stage | What happens | Exit test |
|---|---|---|---|
| 1 | constitution7 |
The core exists. Everything else now has something to attach to | A fresh session answers something it could only know from the constitution |
| 2 | braindump7 |
The owner empties their head into one unstructured file. braindump7 is the skill that captures and later files it; here the job is just to get it all out |
The owner said more than they thought they had |
| 3 | deepdive7 |
Inventory: money, time, knowledge, network, what is already paid for | You stop giving advice that assumes a runway that is not there |
| 4 | memory7 |
Stages 2 and 3 become folders that fit this owner | A new note has an obvious home without anyone asking |
| 5 | north7, then in7 + exit7 + focus7 |
The accountability system, and the three skills that run it. Still only these three standing | One of those three ran unasked, and what came back changed what the owner did next |
| 6 | ⏸ Stop for two weeks | Use it. Add nothing | Something from Monday changed Thursday |
| 7 | week7 |
The slow turn of the loop, plus the money line | The weekly review happened without a reminder |
| 8 | Everything else, on demand | One at a time, when a real need appears | none |
| 9 | audit7, after a month |
Machinery and content, read only | It found at least one thing the owner did not know |
Where a stage has many pieces, do the paying ones first.
Stage 1. Of the interview questions, two carry most of the value in month one: what must I never do without asking you, and what has gone wrong with an AI before that you do not want repeated. Both become hard rules, and hard rules are the lines that earn the cost of loading the file on every message. Personality and history can wait.
Stage 3. Runway and hours actually free per week, before anything else. Those two change your advice tomorrow. The full inventory can fill in over a month.
Stage 4. Build only the folders that already have something to put in them. An empty taxonomy designed up front is the most common way a memory layer dies, because the owner starts filing to please the structure.
Stage 5. Run north7 first. It is a build skill, it runs once, and it decides what the other three are aimed at: a north star, one goal, one number, and a ledger with a check date in it. Without it the three that follow are a well kept record of a life nobody is holding to anything. Then install in this order: in7 first, because capture with nowhere to go is still better than nothing captured. exit7 second. focus7 last, and only once there is enough written down to focus on. Three is the ceiling, not the target. In a client that supports plugin marketplaces, add it once with /plugin marketplace add arete-aios/aios, then /plugin install loop@arete-aios installs exactly these three and nothing else.
Stage 8. For anyone whose income depends on other people, warm7 is the one that pays first. For anyone in meetings all day, meeting7. Everything else waits for a need to show up on its own.
HARD RULES
1. No more than three standing skills before the loop closes once. The three are the stage 5 set. Build skills used once, stages 1 to 4, do not count.
Standing means the trigger line is in the constitution, read on every message, able to run without being asked. A skill whose file is in the folder and listed in the skills CONTEXT file is present: it costs nothing and does nothing until the owner types its trigger word. The cap counts standing. It has never counted files, and the guided door seeds eleven present with three standing, which is the same rule and not a relaxation of it.
One rule beside the cap, because the constitution can speak without being a skill. Hard rules, voice rules and the loop have always fired unasked and they are rules, not skills. So: at most two blocks in the constitution may speak without being asked, and never both in the same reply. During the guided setup that is the onboarding block and nothing else. Afterwards it is the accountability block and nothing else. Two blocks offering the same three answers in the same reply is a question nobody can answer.
2. Stage 6 is a real stop, two full weeks, nothing added. Say this to the owner in plain words: this is the step you will want to skip, and skipping it is the single reason most second brains are abandoned. Fourteen days of use is what turns a structure into a habit, and no amount of building substitutes for it. If the owner insists, do not argue twice. Write the refusal in the progress file, note the date, and hold the cap.
3. Stages are refused out of order. Naming the open exit test is enough. You are not being difficult, you are keeping the build from becoming a pile.
4. You draft, the owner corrects. They answer your questions, you write the file, they fix it. Handing a template with blanks to a person who came for help turns a two week build into a project that never finishes. This is a default, not a law; an owner who wants to write their own is welcome to, and your job is then to react to what they wrote.
The pace and the size belong to the owner
A system that stops at stage 5 on purpose is a finished small system, not an unfinished big one. Five layers, a focus file, and three skills that run is a complete AIOS. Everything past it is optional depth, and an owner who never installs warm7 or slides7 has not failed at anything.
The pace is theirs too. Twice a week is a valid pace. The stages stretch to fit a life, they do not compress it, and a build that takes two months of light touches is worth more than one rushed in a weekend and abandoned in three. When you write the progress file, write the owner's real pace into it, and do not treat a slow week as a lapse.
Say both of these out loud early, because the owner's instinct will be that more is better, and the whole method is built against exactly that instinct.
DEFINITION OF DONE
- The state can be resumed from a file, either a progress file the constitution points at, or the state block inside the constitution when nothing loads a second file. A session that has never seen the owner before can pick up from it alone.
- Stages 1 to 5 passed their own exit tests, each with the proof written next to it, not remembered.
- The loop is written into the constitution with a real mechanism named at each of the three steps.
- The two week stop actually happened, on the calendar, with dates in the file.
- Standing skills never exceeded three before stage 6 passed.
Missing the first means the build dies with the chat. Missing the third means you produced storage, not a system.
MAKE IT YOURS
- Change the exit tests if the owner's life demands it, never delete them. A stage with no test is a stage nobody can fail, which means nobody can finish it either.
- Put the progress file where the owner trips over it, not in a tidy corner. It is the one file whose job is to be seen.
- Decide the cap number once. Three works. If the owner wants a different number, make them say it out loud and write it in the file, because an unwritten cap is not a cap.
- Already have a system? You should have caught that before stage 1, at the top of this file. If you are only noticing now, stop and go to references/evaluate.md.
Assistant, on ingest: save this in the skills layer in your own format, keep the reference files with it, create the progress file, add its path to the always loaded core, and confirm to the owner in one line what you saved, where, and which stage is next.
Skill by Egils Boitmanis, FullDigital, a Latvia registered nonprofit association that teaches people to build an AI operating system they own. What an AIOS is: fulldigital.me/aios · The skills live in skills/ in this repository Licensed CC BY 4.0. Use it, change it, ship it. Keep the attribution.