Each command explained in plain language up top, with the depth power users want below — what it does, when to reach for it, a walkthrough, and the advanced moves. New to this? The setup walkthrough gets you running in about five minutes; come back here when you want to go deeper.
Your core toolkit is covered below, then the opt-in second-act managers — /career, /projects, /learning — in their own group. Start with the ones you'll reach for daily — /brief, /triage, /prep — and dip into the rest as you need them. Putting a command on a schedule is a one-time setup on the walkthrough's scheduler section.
Don't worry about learning commands — learn the moments. Here's how a normal day maps onto your toolkit; the full reference for each command is below.
Your whole day on one screen — today's meetings and who's in them, what needs a reply, top priorities, deadlines this week — before your first coffee.
One pass sorts your inbox into Needs Reply / FYI / Noise and flags calendar conflicts. Nothing is sent — just sorted, so you open a clear inbox.
The invite, the mail thread, the relevant project and people notes, the last decisions and open items — plus the questions likely to come up. You walk in ready.
Your weekly review is already drafted — what shipped, what slipped or is blocked, decisions, next week's shape — with a status update ready to edit and send. (Just one project? /status.)
One search across everything you know — your memory and your notes — answered with citations and honest about any gaps. (Want just the deep dive into your notes? /wiki.)
Correct it once, run /improve, and the lesson becomes a durable rule — the system gets a little more "you" every time you steer it.
Other moments, and the command they call for:
New here? The setup walkthrough gets you running in about five minutes. The full reference for every command is just below.
Turns a correction you just made into a durable rule, so the system doesn't repeat the same miss — the learning loop that makes it more "you" over time.
Right after you fix something — its tone, a wrong assumption, a formatting preference. Claude already jots down some corrections on its own; /improve is how you make the ones that matter stick deliberately. It writes to your own local memory (a plain file you own); nothing leaves your machine.
/improve (or say "remember that" / "bake that in").A capture looks about like this:
Learned this session
· Status updates: lead with the decision, not the backstory — [[status-lead-with-decision]]
· "Acme" = Acme Robotics, not Acme Foods
Saved to memory. These apply from your next session on.
/brief mis-ranks a priority, /triage mis-sorts a sender, or /status misses your tone, correct it, then /improve — each command gets sharper./memory-prune keeps the whole store healthy over time.me/. A "that's not how I work" correction updates me/HOW-I-WORK.md — the standing file every command reads — so it changes behavior everywhere, not just in one memory./improve, if it notices you've steered it the same idiosyncratic way three times across different sessions, it proposes a single standing rule so you stop having to repeat the correction — you accept, edit, or reject it, and nothing lands in your how-I-work file without your yes. It only ever proposes personal preferences (a tone, a "never", how you sign off — never generic "good assistant" behaviour), never nags, and remembers anything you reject so it won't ask twice./improve vs native capture. Claude Code writes some memory on its own; /improve is the deliberate, one-fact-durable version for the corrections you want to guarantee stick.One pass over your inbox and calendar that sorts the noise for you — mail bucketed into Needs Reply / FYI / Noise, plus your calendar conflicts and free blocks — so you start from a triaged list instead of a full inbox.
Monday morning, or any time the inbox has gotten ahead of you. Like /brief it's read-only by default: it reads and sorts, and only drafts a reply, flags a message, or proposes a calendar change when you explicitly ask — and never sends or moves anything without your OK.
/triage (or say "/triage my inbox").A triage looks about like this:
Needs Reply (3) · Finance — Q3 budget sign-off (2 days) · Sam — roadmap review, wants a time · Legal — vendor SOW redlines
FYI (5) · Two newsletters, release notes, an all-hands recap, a calendar invite
Noise (11) · Promotions and automated notifications — safe to skip
Calendar · Conflict: 14:00 1:1 overlaps the design sync · Free: 09:00–10:00, after 15:30
/brief. /brief gives you the day; /triage clears the inbox behind it. A common rhythm is /brief first thing, then /triage to work the pile down./prep. When triage surfaces a meeting you're not ready for, say "prep me for that one" and it hands the details to /prep./improve so the rule sticks. Triage gets more "you" over time./doctor, or re-authorize in your connector settings.Your morning brief — today's meetings and who's in them, what's waiting on you, your top priorities, and what's due this week, all on one screen.
First thing, before your first call — instead of opening five tabs to reconstruct your day. It's also a good midday reset. Because /brief is read-only, it's the safest command to run anytime: nothing it does can send, post, or change a thing.
/brief./prep; say "draft a reply to the first one" and it drafts locally — never sends.A brief looks about like this:
Tue 30 Jun
Meetings · 10:00 Design sync (4 people) — last decision: ship the compare table below the fold · 14:00 1:1 w/ Sam — you owe them the Q3 roadmap
Waiting on you · Reply to Finance re: budget (2 days) · Approve the vendor SOW
Priorities · Website redesign — copy pass · Hiring — close the PM loop
Due this week · Board deck (Thu)
/brief pulls them from your project notes — the more you keep those current (with /status and your vault), the better it reads your actual day rather than guessing./brief with a scheduled task (see the scheduler second act on the setup page) to have a brief waiting each morning — mind the reliability and cost caveats there; a machine that's asleep at 7am silently skips the run./doctor to check, or re-authorize in your connector settings — the cache refreshes when something changes, not on a fixed timer./brief got a priority wrong, tell it, then run /improve to make the correction stick for next time.Everything you need for one specific meeting, gathered onto a single page — the invite, the relevant mail thread, your project and people notes, the last decisions and open items — plus a ready-made agenda, talking points, and the questions you're likely to get.
Right before a meeting you want to walk into sharp: a client call, a team sync, a 1:1. It's read-only — it pulls together what already exists and drafts an agenda; it sends and changes nothing.
/prep and name the meeting — "/prep my 2pm with the design team" or "prep me for the Acme call".A prep looks about like this:
Acme quarterly review · Thu 14:00 · 3 attendees
Context · Renewal is up in 6 weeks; last call they raised onboarding friction
Attendees · Dana (their VP), Chen (their PM), you
Agenda · 1) Onboarding fixes shipped · 2) Q3 roadmap · 3) Renewal terms
Talking points · Support tickets down 40% since the March fix · SSO ships next sprint
Likely questions · "What's the SLA on the migration?" · "Can we add three seats mid-term?"
/prep reads your project and people notes; the more current those are, the better it briefs you. /status and your vault feed it./brief or /triage. Both surface meetings — say "prep me for that one" and /prep takes over./improve so it looks in the right place next time.A ready-to-edit status update drafted from your project notes and recent activity — what progressed, what's blocked, decisions needed, and next steps — written in your template and your tone.
Whenever you owe someone an update — a project check-in, a stakeholder note — and don't want to start from a blank page. It drafts only; you review and send.
/status and name the project — "/status for the website redesign".A status draft looks about like this:
Website redesign — status · week of 30 Jun
Progress · Compare table moved below the fold; hero copy pass done
Blocked · Waiting on legal sign-off for the new privacy page
Decisions needed · Ship the field guide as a second page? (recommend yes)
Next steps · Author the remaining command pages; QA the mobile nav
/status drafts from what's captured, so the more you note decisions and progress as you go, the less you edit. Run /recall first to see what it'll find./status vs /weekly. /status is one project on demand; /weekly rolls up everything for your recurring review (and includes a status update of its own)./improve — after that, /status matches your format by default.A precedent search over your notes vault — "what did I decide or write about X?" — answered with citations down to the exact note and heading.
When you want the deep dive into your own notes specifically: the reasoning behind a past decision, what you wrote on a topic. Read-only recall — it never edits your notes.
A wiki answer looks about like this:
"data-migration decision"
· Chose phased cutover over big-bang — 02 Projects/Migration > Decision
· Rollback: keep the old DB read-only for 30 days — 02 Projects/Migration > Risk
· Related: the vendor SLA thread — 03 Areas/Vendors/Acme > SLA
/wiki vs /recall. /wiki is vault-only, with heading-level precision and graph enrichment. /recall casts wider — memory, vault, and command work product at once. Use /recall for "what do I know?", /wiki for "what did I write?"./ingest, /status, plain notes), the more precedent it finds./wiki never changes a note. To turn raw sources into linked notes, that's /ingest.One question — "what do I know about X?" — answered across all your knowledge at once: your maintained memory, your notes vault, and the work your other commands produce and keep (a tracked list, a strategy doc, research). Ranked together, cited, and honest about where you have gaps.
Any time you're sure you decided or noted something but can't find it, or you want the full picture before a meeting or a decision. It's strictly read-only — it never writes to any store.
A recall looks about like this:
What you know about "website redesign"
Decision · Ship the field guide as a second page — [[field-guide-second-page]]
Note · Compare table below the fold — 02 Projects/Redesign > Layout
Tracking (live) · 11 command docs remaining — product-backlog/BACKLOG.md
Related · Connector-auth refresh, mobile-nav QA
Gaps: nothing recent on the privacy-page copy; the layout note is 3 weeks old
/recall vs /wiki. /recall spans everything — memory, vault, and command work product. /wiki is the vault-only deep dive with heading-level citations and graph enrichment. Reach for /recall first; drop to /wiki when you specifically want precedent from your notes./recall leaned on a stale note or couldn't cover a term, it says so. Treat work-product hits (a tracked list, a pipeline) as current state, not settled precedent./recall reads a small manifest of which command folders and files to surface. As you add commands that produce durable knowledge, adding them to that manifest lets recall find them — read live at query time, never copied, so nothing goes stale./recall is read-only by design. If it surfaced something wrong or missing, fix the underlying note and run /improve; recall reflects it next time because it reads sources live.Your recurring weekly review, pre-built — what shipped, the decisions, what slipped or is blocked, and the shape of next week — plus a ready-to-edit status update to send.
End of the week — Friday, or whenever you do your review. Instead of reconstructing the week from memory, you start from a draft that's already assembled. Draft only; you send it.
/weekly.A weekly review looks about like this:
Weekly review · week of 30 Jun
Shipped · Field Guide pilot live · Compare table repositioned · Connector-auth refresh
Decisions · Grew AI-OS to a second public page (the guide)
Slipped / blocked · Long-tail command docs (11 remaining) · Privacy page (legal)
Next week · Author remaining command pages · Recruit the novice test
Sharper this month (monthly) · You corrected status-update openings 3× → now a
standing rule, applied to the last two drafts without a fix · /prep now pulls the
attendee's last email thread — useful for your Monday 1:1s
/weekly adds a short mirror of how the system got sharper at your work — the corrections it turned into standing rules and has since applied, and (when relevant) a new capability that helps something you actually do. It shows the change, not a list of what it knows. It stays completely silent any month it has nothing real to show — it's a mirror, never a nag. Run it on demand any time with /weekly sharper./weekly vs /status. /weekly is the whole-week rollup for your standing review; /status is a single project on demand. Because /weekly bundles a status draft, many people run only /weekly on Fridays./improve) and Friday's draft writes itself./weekly with a scheduled task (see the scheduler second act on the setup page) to have Friday's review waiting — mind the reliability and cost caveats there; a machine that's asleep silently skips the run./improve, and it matches your recurring format from then on.The workshop for your toolkit — find, create, and audit your own commands as your needs grow, following Anthropic's skill-authoring best practices.
When the built-in commands don't quite cover something you do repeatedly, or you want to check an existing skill is well-formed. This is the expert on-ramp — how AI-OS grows with you instead of boxing you in.
/skill-center and say what you want — "create a command that drafts my expense report" or "audit my /triage skill".A session looks about like this:
Skill Center
· Installed: 17 commands · 1 flagged (missing a clear trigger)
· Created:/expenses— drafts a monthly report from your receipts folder
Start a fresh session to register the new command.
/command can "do nothing" until then (/doctor confirms what's registered)./skill-center just makes authoring them follow the good patterns.Turns raw sources you drop in — clippings, transcripts, meeting or Teams exports, reading — into maintained, interlinked concept pages, so you synthesize once and navigate later instead of re-summarizing the same material every time.
When you've collected material you'll want to reuse — research, meeting exports, articles — and don't want a growing pile of unprocessed files. Safety fence: it writes end-to-end only inside your Synthesis folder; everywhere else in your vault it's propose-only (a link into one of your own notes is a suggestion for your review, never a silent edit).
_inbox/ folder./ingest. For each source it reads it, then for each distinct idea creates or updates a short, cited concept page (one idea per page) with [[wikilinks]] to sibling pages._inbox/processed/ — so your inbox stays clean and your knowledge stays linked.A run looks about like this:
Ingested 3 sources → 5 concept pages
· New: Synthesis/context-windows.md, Synthesis/rag-vs-finetune.md
· Updated: Synthesis/agent-harness.md (+2 links)
· Archived raws → _inbox/processed/ · Rebuilt Synthesis/index.md
Suggested 2 links into your hand-authored notes — review before applying.
/ingest owns the Synthesis folder end-to-end but treats the rest of your vault as propose-only — your hand-written notes are never silently edited./wiki and /recall. Everything /ingest builds becomes searchable precedent; the more you ingest, the richer those answers.An on-demand health check for your memory — it verifies each memory is still true, fixes drift, rebuilds the index, and flags what's stale or orphaned, proposing deletions for your OK. It never auto-deletes.
Every so often as your memory grows, or when answers start feeling out of date. This is the maintenance half of the memory lifecycle — what keeps a long-lived memory true rather than just large.
/memory-prune.MEMORY.md index (grouped, one line each), and flags orphans and dangling [[links]].A run looks about like this:
Memory check · 84 memories
· Fixed 6 relative dates → absolute · Rebuilt MEMORY.md index
· 2 dangling links, 1 orphan flagged
· Proposed for deletion (your OK): "trial ends Friday" (expired) · duplicate of [[acme-contact]]
/memory-prune never deletes on its own — you approve every removal. That's the deliberate trust posture./improve grows it, /memory-prune keeps it true. One captures new rules; the other re-verifies, de-dupes, and fixes drift — the maintenance native memory doesn't do./doctor tells you when. /doctor flags when your store has grown big enough that a prune is worth running.Runs a real decision past a panel of advisor profiles — experts whose thinking you admire, each distilled into a note in your vault — and synthesizes their distinct takes: where they'd agree, where they'd dissent, and a recommendation.
For a decision worth several sharp perspectives — a hire, a strategy call, a design trade-off. It's advisory and read-only, grounded only in the profiles you've curated (no external lookups).
A board run looks about like this:
The board on: "ship docs as a second page?"
· Advisor A (systems) — yes; keep the main page lean, docs are a separate job
· Advisor B (growth) — yes, but link it where users hit friction, not just the footer
· Advisor C (minimalist) — dissents; wary of a second thing to maintain
Synthesis · Strong lean yes; the live risk is maintenance — generate it, don't hand-write.
/board reasons only from your profiles — no external API — so it won't fabricate a stance the profile doesn't support.03 Areas/Advisors/) as plain notes you can edit.A stateful tutor for learning a topic over many sessions — it keeps a syllabus and your progress, and picks up each time exactly where you left off.
When you're learning something bigger than one sitting — a system, a skill, a subject — and want a course that remembers you rather than starting over each time.
A session looks about like this:
System design · session 4
Last time: caching, load balancing (you were shaky on cache invalidation)
Today: consistent hashing → a quick check → then sharding
Progress saved to 04 Resources/Learning/system-design/
/ingest and /recall. Turn course material into concept pages with /ingest; recall what you learned later with /recall or /wiki.Turns a system or process you describe into one self-contained interactive HTML diagram — clickable nodes, hover detail — that you can open in a browser.
When a wall of text would be clearer as a picture: an architecture, an approval flow, how a project's pieces connect. Good for sharing, or for thinking something through visually.
04 Resources/Diagrams/) and gives you the path to open.A run looks about like this:
Release process → diagram
7 nodes: PR → CI → review → staging → QA → deploy → monitor
Saved: 04 Resources/Diagrams/release-process.html — open it in your browser.
Protects your whole AI-OS — memory, notes, and your skills — against a lost or wiped machine. One command keeps an on-disk history and tucks an encrypted copy into the cloud folder you already sync (the 3-2-1 rule), no setup required.
Regularly, and before anything risky — a big cleanup, a migration. Your skills live outside ~/ai-os, so nothing else captures them; this is the one thing that does.
/backup. With no arguments it just works.~/ai-os to its own git history (the cheap, frequent layer), builds a timestamped full snapshot under backups/, encrypts it, and drops the encrypted copy into your synced cloud folder.A backup looks about like this:
Backup complete
· Committed ~/ai-os (git) · Snapshot backups/2026-06-30T09-12.tar.gz.enc (encrypted)
· Copied offsite → your cloud folder
Memory, notes, and 17 skills all captured.
--full, --no-encrypt, --to <path>, --dry-run; a backup.config.yml tunes destinations, retention, and what's included.~/ai-os, /backup deliberately reaches out to include them — a plain vault sync would miss them./restore --drill. A backup you've never restored is only a hope; the drill verifies it into a throwaway copy without touching your live system./doctor watches its age. /doctor reports how old your most recent backup is, so a stale one is visible./restore). One live writer at a time.Brings your whole AI-OS back from a snapshot — after a new laptop, a bad edit, or a lost folder. It picks the newest snapshot, lays everything back, and is fully reversible.
When you need your system back — recovery, a fresh machine — or when you want to prove your backups actually work (with --drill, safely). Anything it would overwrite is moved aside first, so a restore can itself be undone.
/restore. It lists the snapshots it can find — local and in your cloud folder — and defaults to the newest.--dry-run to see exactly what it would change before committing.A dry run looks about like this:
Restore (dry-run)
Source: backups/2026-06-30T09-12.tar.gz.enc (newest)
Would restore: memory/ (84 notes), notes vault, 17 skills
Existing files → moved to restore-backup/ first — nothing lost.
Re-run without --dry-run to apply.
--drill proves a backup. It restores into a throwaway copy, never touching your live system — the honest test that your /backup actually works.--dry-run first. See the exact change set before you commit — especially on a machine that already has data./backup. Together they're your recovery quadrant; /doctor tells you the safety net is current./backup+/restore are for recovery and migration — rebuilding your AI-OS on a new or wiped machine — not for keeping two machines in sync. Your memory, notes, and git history assume a single writer; a restore overwrites (reversibly), it doesn't merge. Migrating? Restore on the new machine, then stop using the old one. Genuinely want two live machines? Sync ~/ai-os and ~/.claude/skills with a real file-sync (Syncthing, or a shared git remote you pull/merge) — not backup/restore.A read-only checkup for your system — are your connectors still signed in, your memory and commands healthy, your last backup recent, and is your AI-OS itself up to date? It reports what needs attention and points you at the fix; it changes nothing.
Any time something feels off — a command "does nothing", mail looks stale — or as a periodic once-over. It's strictly inspect-and-report: it never changes, deletes, or sends anything.
/doctor./mcp — the thing most likely to be quietly broken), Memory (exists, rough size, note count, whether a /memory-prune is worth it), Toolkit (which skills are registered under ~/.claude/skills/), Protection (the age of your most recent /backup), Currency (whether your installer build and command roster have fallen behind the current AI-OS — if so, it points you at re-running setup, which upgrades in place), and Standing work (if you've scheduled a manager to draft between sessions, whether it's actually still running — a silently-skipped run is worse than none)./doctor for the deeper system layer (install, versions, config).A checkup looks about like this:
/doctor · AI-OS health
✓ Connectors — Google signed in · Memory — 84 notes (~180 KB), healthy
⚠ Toolkit — 16 of 17 skills registered (/expenses needs a fresh session)
⚠ Protection — last backup 9 days ago → run /backup
⚠ Currency — build 2026.05.12a is behind current 2026.06.30m; missing /restore, /update → re-run setup once to catch up (it upgrades in place, adds only what's new) — after that, /update does this for you
What's new for you — the newer build's /brief now drafts your morning digest before you're even at your desk
⚠ Standing work — your /projects check-in hasn't run since Jul 1 (expected weekly) → check its routine (a sleeping laptop skips runs)
For install/version checks, run Claude Code's built-in /doctor.
/doctor reads live auth via /mcp and points you to re-authorize./doctor shows the count; start a fresh session to register newly-built ones./doctor, doesn't replace it. AI-OS /doctor covers AI-OS-specific state; Claude Code's built-in /doctor covers install/config/versions. Run both./doctor only tells you your build or command roster is behind; if you have /update, say it and it fetches, verifies, and hands off to the same upgrade mode automatically — if you don't have /update yet, re-paste the setup prompt manually once (upgrade mode detects your install, adds only what's missing, leaves your memories, notes, and customized skills untouched). /doctor itself changes nothing, and if you're offline it just skips the currency check./backup (it tells you your safety net is current) and /memory-prune (it tells you when one's due)./doctor reads a small heartbeat file and tells you if a scheduled run has quietly stopped — a sleeping laptop, a deleted routine, an errored run. It only reports and points you at the fix; it never re-runs or restarts anything.Turns the reasoning of a session you just finished into durable, routed knowledge — the rules and preferences into your memory, the decisions and what-you-learned into your notes vault — so a session that mattered doesn't evaporate when you close it.
At the end of a session where real thinking happened — a decision got made, an approach got chosen, you learned something worth keeping. /improve captures a correction into memory; /ingest files raw notes you drop in; /capture is the one that closes a whole working session across both brains. Everything stays in plain files you own; nothing leaves your machine.
/capture (or say "write that back")./improve contract. Both stores stay yours to edit./capture vs /improve. /improve is the fast, memory-only "bake that in" for a single correction. /capture is the both-brains session close — use it when a session produced a decision worth a durable note, not just a preference./recall. What /capture files, /recall finds later — the write-back and read-back ends of the same knowledge loop.Lets you give a capability you've proven to a friend — and safely accept one — as a single plain-markdown file you can both read. Stripping, provenance, and a review-before-install gate are built in.
When a command or domain setup has genuinely earned its keep and someone you know would want it — or when a friend sends you theirs.
tier: adopted + origin stamps forever; they never touch me/ or memory, and suggested rules route one at a time through /improve's normal accept gate./doctor can list what you've adopted and from whom.Fetches the current setup prompt from the AI-OS repo, checks it's byte-exact against a checksum before touching anything, and hands it into this session as if you'd pasted it yourself — then lets the setup prompt's own upgrade mode (the same one that runs when you paste by hand) decide what's new and wait for your OK. If you're already current, it says so and does nothing else.
Any time /doctor's currency check says you're behind, or whenever you feel like checking — it's free to run and does nothing if there's nothing new.
/update./doctor uses)./update only delivers a verified, unmodified copy of the current prompt — every decision about what changes is made by the prompt's own upgrade-mode section, the same one you'd trigger by pasting manually.meta.yml) is checked locally against what actually landed on disk — if the fetch ever came back altered, it's caught, and /update refuses to run it rather than guess./update degrades honestly to "paste it yourself," which is exactly today's flow, not a regression.cvp1/ai-os's main branch — never a URL you or anything else supplies./doctor. /doctor tells you you're behind and what it'll cost you to stay there; /update is the one-command fix when it can be.These aren't part of the core setup. You hire them after your first win, one paste at a time, from the bench on the setup page — a standing chief-of-staff for one part of your life. Each drafts and proposes; you always approve.
/career is a standing career chief-of-staff. It learns how you write from a few of your own samples, keeps a living career strategy, and drafts LinkedIn posts in your voice — you always publish; it never posts anything or edits your profile. Everything lives in ~/ai-os/career/, so it shares your memory and /recall.
When you want to show up in your field on a cadence without it sounding like generic AI, or when you want a standing view of where your career is headed rather than one-off help. It's an opt-in second act — hire it after your core AI-OS is running and you've had your first win, not before.
The one-time setup interviews you: you paste 3–5 things you're proud of writing (mix a public post, a colleague email, and your bio), answer three short questions about what you want to be known for, and it distills a VOICE.md fingerprint — then reads it back and asks "anything wrong, or just not you?" Once it's running, drive it by mode:
You: /career post about the migration project I just wrapped
/career: Draft (graded against your voice rubric, checked against RULES.md):
"Six months ago we bet on a phased cutover instead of a big-bang migration…"
— sound like you? I can sharpen the open or cut the third line.
/career post — drafts a post from your strategy or recent work, in your voice, staged to ~/ai-os/career/proposals/ for you to publish./career voice — reviews or refines your voice model; run /career voice learn after you reword one of its drafts so it remembers the difference./career status — where your career strategy stands./career onboard — refine the strategy later as things change./career research — background research for a post or a move./career voice learn. Voice is a compounding correction, not a one-shot clone.RULES.md: it never exposes employer- or client-identifiable information — generalizes to "a large enterprise" / "a recent project," never reproduces internal documents or non-public numbers./projects is a manager for one project you own — it keeps that project's strategy, backlog, and decision log (the same STRATEGY / BACKLOG / DECISIONS shape that runs this very product) and drafts the weekly status update you actually send, pulled from the plan rather than written from scratch. It drafts; you send. It never posts an update or edits a shared doc. Everything lives under ~/ai-os/projects/<slug>/, so it shares your memory and /recall.
When a project you own needs a steady drumbeat — a status on a cadence, a place decisions don't get lost, a backlog that stays honest — and you'd rather steer than re-draft the update every week. Opt-in second act; hire it after your first win.
Setup interviews you about the project itself — its goal / North Star and roughly by when, who reads the status, how often you report and what a good update covers, and how you'll know each milestone is truly done — then reads it back and asks "anything wrong or missing?" before it seeds the workspace. Then:
You: /projects update
/projects: Draft weekly status — Website Relaunch, week of Jun 30:
Progress · Checkout redesign shipped to staging…
Risks · Vendor SLA sign-off still open (owner: Procurement)…
Decisions needed · Confirm the phased-cutover date…
— this the update you'd send? I can tighten the risks or add an ask.
/projects update — drafts your next status from where things actually stand./projects check-in — drafts your due status on its own; run it, or schedule it to draft while you're away./projects status — where the project sits right now./projects decide — record a decision in the log./projects onboard — refine the strategy / cadence later./projects research — background research for the project.~/ai-os/projects/<slug>/ folder sharing the personas.RULES.md — it never puts employer- or client-identifiable information into anything meant to leave the team./projects check-in drafts your due status and stages it — run it yourself, or put it on a schedule with the "Run it without you" setup so it drafts while you're away. It only ever stages a draft (never sends), it surfaces one waiting draft the next time you're in /projects (never nags between sessions), and /doctor warns you if a scheduled check-in ever stops running./learning is a standing strategist for everything you're trying to learn. It keeps a living portfolio of your goals and a prioritized, prerequisite-ordered topic queue across all of them, drafts a roadmap for a goal, and tells you what's gone cold and worth revisiting. It plans; /teach teaches — it hands each topic to /teach (the tutor that already ships with your AI-OS) and never runs a lesson itself. Everything lives in ~/ai-os/learning/, so it shares your memory and /recall.
When you're trying to learn several things at once and want an order that respects prerequisites and your time, instead of learning at random — and a standing "what should I pick up next, and what have I let go cold?" Opt-in second act; hire it after your first win.
Setup interviews you about your whole learning portfolio — what you want to be able to do (concrete outcomes), why each matters, what you already know, and how much time you realistically have — then reads back a suggested order and asks "anything wrong or missing?" The first win is a roadmap that ends by handing you off to /teach:
You: /learning roadmap for "ship a small web app"
/learning: Prioritized roadmap (needs-X-first noted):
1. HTML/CSS basics — the surface you'll build on
2. JavaScript fundamentals — needs #1
3. START HERE → a first small page…
When you're ready, run/teach me HTML/CSS basics— it keeps a syllabus and remembers where you struggle.
/learning roadmap — drafts a prioritized, prerequisite-ordered roadmap for a goal, ending in a /teach handoff./learning review — a weekly "what's gone cold and is worth revisiting."/learning status — where your learning portfolio stands./learning decide — record what to start, pause, or drop./learning onboard / /learning research — refine goals later; find roadmap-level sources./teach owns everything inside a topic (the syllabus, the lessons, your progress). The manager reads /teach's progress to spot cold topics; it never writes inside a topic's lesson workspace or builds a syllabus./learning review is a weekly "what to revisit," not per-card spaced repetition — it's a pull-based digest, not an optimal-interval reminder system./teach yet? It'll offer to walk you through the first topic once — it never builds its own tutor.