🔴 Field Report
AIOS Mastermind Recap & Learnings:
My First AIOS-as-a-Service
A debrief from a full-day in-person AIOS mastermind with 5 business owners in Cape Town —
the first real-world delivery of AIOS as a service. What crystallized: a refined automation spectrum
with a new "Supervised" stage, the definitive skills vs. commands taxonomy, and how to walk
a complete workflow from manual to automated.
Section 01
Who Was in the Room — Why the Mix Mattered
The mastermind was deliberately assembled to include a range of business types, sizes,
and AI literacy levels. That mix made the delivery hard — and the learnings rich.
Seeing where people got stuck, where they lit up, where the framing needed work —
all of that comes from the diversity in the room, not from a homogeneous group.
Richard
eLearning platform — corporate training, mid-to-large companies in South Africa. Moving into AI certifications.
AI user — not yet on Claude Code
Brian
Venture studio — portfolio of 6–8 ecommerce companies, significant combined turnover. Wife had watched YouTube videos and attended event.
Basic Claude Code familiarity (wife)
Sybil
Civil Holiday Brokers — premium travel and holiday property brokerage.
Occasional ChatGPT user only
Linus
AI SaaS + voice AI agency — got agency clients through SaaS partnerships without marketing.
AI fluent — was using CoWork
Adrian
AI content and training business. Highly AI fluent.
AI fluent — not yet on Claude Code
The exit (special guest)
Previously ran an influencer marketing agency — sold for ~£30M. Now advising on next chapter for the Morningside Group.
Strategic — not a builder
💡
The key insight from running this room: Everyone wanted full automation immediately.
Every single person. The job of the session was partly content delivery and partly expectation management —
helping them understand that the path to automation runs through augmented, then supervised,
before you get to automated. And that this isn't a failure — it's the process.
Section 02
The Expanded Automation Spectrum — "Supervised" Is New
Through the process of teaching this in person, the automation spectrum got refined.
A new stage — Supervised — crystallized between Augmented and Automated.
It's distinct enough to deserve its own name, because the business implications are different.
0%
Manual
Human does every step. May have SOPs or may be ad hoc each time.
SOP or random
80%
Augmented
You invoke the workflow. AI does 80% of the work. You guide key decision points.
→ Slash commands
96%
Supervised ← NEW
Runs on a schedule or trigger. You don't initiate it — you just review the outputs afterward.
→ Cron + output review
100%
Automated
Fully autonomous. Runs, acts, and publishes without any human review loop.
→ Cron + auto-publish
The key distinction between Supervised and Augmented:
Augmented means you invoke it and you're in the loop. Supervised means it runs without
you, but you check the batch of outputs before anything ships. It's 96% off your plate
mentally — you're not running the process, you're reviewing results.
🧠
The mental bandwidth unlock of Supervised: When a workflow is augmented,
it still occupies mental space — you know you have to do it. When it's supervised,
it's handled. It runs on Sunday, it produces outputs, you review them Monday.
That's a completely different psychological experience of running a business.
Freeing mental bandwidth is as valuable as freeing time.
Section 03
The Risk Dimension — Picking the Right Level
The automation spectrum has a second axis: business value × business risk.
The right level of automation for any task isn't just about what's technically possible —
it's about whether the output going wrong has meaningful consequences.
✓ Safe to fully automate
Low value, low risk tasks
Data collection, funnel analytics reports, AI doc scans, status checks, discovery call prep, system pings. If these are wrong or delayed, the consequence is minimal. Full automation is appropriate here — it runs in the background, you don't need to see every output.
⚠ Keep at Supervised or Augmented
High value, high visibility tasks
Client-facing content, course material, proposals, strategic decisions, emails to important contacts. If these are wrong, the business consequence is real. These belong at Augmented or Supervised — never fully automated — until you've had extensive, proven output quality across many runs.
⚡
The prioritization question isn't just "can I automate this?" — it's "what's the cost if it goes wrong?"
Scoring tasks on both axes (time saved × cost of error) gives you a heat map of where to focus.
High time savings + low error cost = automate first. High time savings + high error cost = augment first,
then supervise when you trust it, then evaluate if full automation ever makes sense.
Section 04
Skills vs. Commands — The Definitive Taxonomy
This is the clarification that finally crystallized through the act of teaching it in person.
The terminology of "skills" had been doing too much work — covering things that are
fundamentally different. Here's the clean breakdown.
Capabilities
Always-on, non-invocable context skills
Skills with user_invocable: false. Their description stub is injected into every session automatically. The AI sees them at startup and knows when to reach for them — you never call them explicitly. Examples: SuperData (transcripts), Circle API integration, writing style guide.
Key signal: you can't slash-invoke them. They just activate when relevant.
Commands
User-invocable, lightweight, no context injection
Markdown files in .claude/commands/. You invoke them with a slash prefix. Their name appears in the context, but not a full description — so the AI knows they exist but doesn't carry their content in every session. Good for structured step-by-step workflows you run on demand. Example: /create-plan, /prime, /course-module.
Key signal: slash-invocable. Description is NOT in the running context by default.
Skills (invocable)
User-invocable, with SKILL.md description injected into context
A folder with a SKILL.md entry file. The description stub IS injected into context — the AI always knows what this skill can do and triggers on it when relevant, even if you don't invoke it. Can have sub-folders with examples, references, and scripts. Heavier than commands but expandable. Examples: front-end design skill, thumbnail gen skill.
Key signal: SKILL.md description is always in context. Expandable with folders.
🔑
The core distinction: Capabilities give the AI always-on awareness of a tool —
it reaches for them automatically. Commands are prompt templates you manually trigger —
pure step-by-step instructions, name only in context. Skills are the middle ground —
invocable like commands, but their description is always in context so the AI can also
trigger them autonomously when the situation calls for it.
Section 05
Workflow Walk-Through — Course Module Factory
The course module creation workflow was used as the live example to show how a long manual
process moves through augmented → supervised. This is also a worked example of how to think
through automation planning for any multi-step process.
1
Research
Scrape community questions, YouTube comments, competitor content. Identify gaps.
Augmented: AI does research → you confirm direction
2
Ideate
Generate module ideas, topic angles, format decisions (tutorial vs whiteboard vs talking head).
Augmented: AI generates → you select + refine
3
Plan
Structure the module, decide what goes in, what order, what level of depth.
Augmented: chat back and forth until clear
4
Write
Script or outline the content. For talking head / concept content, agent avatar can handle fully.
Augmented → Supervised for theory content
5
Review
Quality check before production. Could eventually pass to team.
Manual — or delegated to team
6
Film
Tutorial content requires on-camera presence. Not automatable for now.
Manual (human required)
7
Edit
Rough cut automation exists. Full editing pipeline is complex but worth pursuing eventually.
Augmented (rough cut) → eventual supervised
8
Publish
Automated publishing to platforms. Low risk, high repeatability — prime candidate for full automation.
Automated → full autonomous
The Supervised upgrade for this workflow: every Sunday, the system scrapes
community questions, runs the research → ideate → write pipeline autonomously, and delivers
5 fully drafted module options. You review and pick on Monday. The mental load of "I need to
make course content" disappears from your weekly plate — it's already handled.
Section 06
Code + Natural Language — Why This Changes Everything
The deepest insight from the mastermind: explaining why AIOS-style automation is fundamentally
different from everything that came before it. The magic is in wrapping deterministic code
with natural language orchestration — what was called the "gooey soft wrapper."
The old way (Zapier / Make)
Step 1: Load business context
Pull doc from Drive v3.2
Pull another doc...
If condition A → branch X
Else → branch Y
Node 12 of 40...
→
Rigid. Brittle. Every edge case = a new node. Error = complete failure. Non-experts can't read or modify it.
The AIOS way (code + natural language)
Python script: pull_context.py
Python script: fetch_data.py
Python script: post_to_platform.py
+
"Load the business context, then fetch the latest data. If there's a discrepancy, flag it and continue. Run the analysis and produce 5 options. If anything fails, note it and move to the next step."
- Scripts provide the reliability floor. Deterministic Python/shell scripts that always do the same thing — fetch this data, call this API, write to this file. These are the hard parts that must be exact.
- Natural language provides the flexibility ceiling. The LLM orchestrates when to call which scripts, handles the if/then logic in plain English, reasons through edge cases, and adapts to unexpected situations without needing a new node.
- Self-correcting by design. When something fails, the natural language layer can reason about the failure, try alternatives, log what happened, and continue — all without rigid error-handling code. This is what makes AIOS-style automation so much more robust than n8n flows.
- Easily editable by non-engineers. Changing the workflow is editing a markdown file in plain English, not rewiring a 40-node Zapier diagram. The entire team can read, understand, and propose changes to the automation logic.
Section 07
The Prioritization Heat Map — What to Build First
When you have a task audit with 20–50 items, you need a framework to decide what to automate
first. The heat map framework plots each task on two axes. The top-right quadrant is where
you start.
- Axis 1 — Automation Potential (AP): How straightforward is this to automate? Is it a repeatable, well-defined process? Does it have clear inputs and outputs? Or is it highly contextual, creative, and judgment-heavy?
- Axis 2 — Expected Value (EV): How much time and mental bandwidth does this currently consume? What's the business impact if it goes faster or happens automatically? What's the risk if it's wrong?
- Top-right (High AP × High EV) = automate first. These are your quick wins AND big wins simultaneously. Data collection, daily reports, funnel analytics, research tasks — high value, high repeatability.
- Top-left (Low AP × High EV) = augment, not automate. High value but requires judgment — client proposals, strategic decisions, creative content. Start augmented; move to supervised only when output quality is consistently proven.
- As a practitioner delivering this for clients: you should know this heat map. A business owner can't evaluate automation feasibility — they don't know what's technically hard. Your job is to look at the task audit, score each item, and tell them where the quick wins and big swings are.
Section 08
Team Sharing via GitHub — The Current Best Approach
Multiple people on separate AIOS instances who need to share context is still unsolved cleanly.
The best current approach uses GitHub as the sync layer. Still rough — but workable for
business partners. More dangerous for full team rollouts.
- Each person has their own repo. Your workspace stays yours. Context files, commands, and personal preferences all private. No one touches your machine's files directly.
- A shared repo holds the shared context. A third GitHub repo that both parties have access to. Contains the shared business strategy, shared data, shared modules that both need to be aware of. A
/pull-shared command syncs it down on demand.
- Commit flows: each party pushes to their own repo. Anything that should be shared gets committed to the shared folder. Both can pull it down whenever they need the latest. Git pull = sync.
- Business partners = manageable. Team members = dangerous. When your partner has full git access, you trust them to not break things. When a non-technical team member has write access to your AIOS files — API keys, scripts, context — that's a security and stability risk. Solve permissions before scaling to teams.
⚠️
This is still being worked out. Full team sync — where multiple non-technical employees
each have a scoped AIOS instance that pulls shared context and stays up to date —
is not yet a solved problem. Stay focused on founder-first delivery until a clean
methodology exists for team rollouts.
Key Takeaways
What Crystallized from the Room
Takeaway 01
Everyone wants automation; the path runs through Supervised
In the room, every single business owner wanted full automation on day one. Teaching the spectrum — and why Supervised is the real win before Automated — is as much a mindset shift as a technical education.
Takeaway 02
Supervised is a distinct and valuable stage
It's not a step toward automated — it's often the right destination. Runs without you, you review outputs, mental bandwidth freed. For high-value tasks with meaningful error risk, Supervised may be the permanent answer.
Takeaway 03
Capabilities / Commands / Skills — now clearly defined
Capabilities = always-on, non-invocable, context-injected. Commands = user-invoked, lightweight, no context injection. Skills = user-invocable or AI-triggered, SKILL.md description always in context. Three different tools for three different jobs.
Takeaway 04
The "gooey wrapper" is why this beats n8n
Hard scripts for the deterministic parts. Natural language for orchestration, edge cases, and error handling. Self-correcting. Human-readable and editable. What used to be a 40-node diagram is now a markdown file.
Takeaway 05
Use the heat map to prioritize delivery
Automation Potential × Expected Value. High AP + High EV = automate first. High EV + Low AP = augment first. As the practitioner, you can read this heat map from the task audit. Your client cannot — that judgment is the value you bring.
Takeaway 06
In-person delivery surfaces things you can't see online
The gaps in the framing, the points that confused people, the moments that lit them up — all invisible until you're sitting at a table together. If you can do in-person delivery, do it early and often. The learnings are worth the travel.
Continue Learning
Related Modules