THE FORGE · Module 0

Start Here

0:00 / 0:00

This is the locked pattern all remaining modules inherit — the three layers:

  1. What actually happened — a real, dated incident from the real system, cited to a commit / jarvis-os/goals/*.md / CHANGELOG entry. Never invented, never generic.
  2. The same lesson, stated generically — stripped of PL-specific nouns so it transfers to the reader's own work.
  3. The building block — the concrete copyable artifact: template, folder structure, checklist, skill scaffold. Not advice, the thing itself.

Section order: what's in the box → what you'll learn → dependencies → why it exists (honest origin) → what the system actually is (honest scale) → the three-layer contract → credentials → attribution → living document → the teaching + Three Truths → the building block → before the next module.

Standing constraints, all modules: no transcript text on the page (transcripts inform understanding only); no secrets, credentials, account IDs, revenue figures, *.local.md contents; no personal material; the employer is never named; third-party tools are named as used, never as built, with attribution verified at write time.

All 7 certification dates and verify links independently verified against the live Anthropic Academy profile before crowning. Bio uses the brand-safe version per founder direction (zero-capital 2020 start, built it himself, seven-plus years of practice, the mission to teach it — no private material).

What's in the box

THE FORGE is two things, not one:

  1. The Hive Mind Starter Kit — a real, working second brain, ready to use today. CLAUDE.md, four real Claude Code skills, agent memory templates, a prompt library, a workflow library, a setup script, and an offline reference app. You don't need to finish a single course module to start using it — point Claude at it and start talking about what you're building.
  2. Eleven modules, self-paced — the actual sequence this was learned in, not a generic "AI agents" curriculum. Complete them on your own terms. No live sessions to catch, no schedule. Questions go to forge.help@psychedluxuries.com — real answers, not a bot.

Both arrive the moment you enroll.

What you'll learn

Eleven modules, each paired with a principle from the practice — not two separate tracks, one system:

  1. Start here (this module) — orientation, dependencies, what's ahead
  2. The spec, before the code
  3. One agent, then a fleet
  4. Skills as durable memory
  5. The self-improvement loop
  6. Per-agent memory
  7. Scheduled automation, safely
  8. Deploy discipline
  9. The reconcile habit
  10. The correction loop — spec, ship, improve
  11. Marketing (taught last, once there's something real)

Realistic time: 2–4 hours to get the starter kit running and useful on its own. 20–30 hours for the full set of modules, hands-on to your own project — most people spread that across 2–4 weeks alongside a normal week, not a weekend sprint.

What you need before you start

  • Claude Code — your own subscription. THE FORGE doesn't include or resell this; it's the tool the whole system runs on.
  • Obsidian — free, this is where your own second brain lives. Obsidian Sync is optional, only useful if you want it on more than one device.
  • Cloudflare — free tier, only needed once you get to deploy discipline (module 7) if you choose to ship something of your own.
  • No coding or programming knowledge required. It helps, but it is never the gate — the whole point of Claude Code in this system is that you describe what you want in plain language and it does the technical work. If you've never written a line of code, you can still complete every module here.

Why this exists — the honest version

Most courses open by establishing that the author is disciplined and you are not. This one opens the other way.

The person who built this system was the kid who didn't study, didn't do homework, walked into class without knowing there was a test, and still came out with an A or a B. That sounds like a flex. It isn't. It's the diagnosis. When results arrive without effort for long enough, you never build the machinery that effort requires — and the first time something actually demands sustained, unglamorous, repeated work, you have nothing to reach for. The work felt like work. That was the problem. Not the difficulty of it. The texture of it.

That same pattern followed into employment. Not a story about a bad job or a bad manager — a story about a person who could see exactly what needed doing, could do it well in a burst, and could not reliably do it the same way on day forty as on day one. Consistency was the missing organ.

There are two responses to learning that about yourself. One is to try harder — to promise, again, to become the sort of person who is naturally consistent. That promise has a well-documented success rate.

The other is to stop trying to fix the person and build the structure that holds the discipline instead.

That is what this entire system is. Not a productivity stack. A compensating structure. Every rule taught in this course — write the spec before the code, verify before you claim, reconcile the list against reality, close the session the same way every time — exists because a human being could not be trusted to remember it under pressure, at 4 a.m., on the fortieth day. So the rule got written into a file that never gets tired, and the machine holds it.

Read that as the thesis of the course: you are not building a system because you are organised. You are building it because you are not, and you have decided to stop pretending otherwise.

Psyched Luxuries started in 2020 with zero capital — one person building the site, the designs, the products, and later the entire operating system that runs it, from scratch, mostly at night, around a full-time job on a schedule that put the brand work between midnight and dawn. What's taught in these modules isn't theory. It's the actual sequence that turned a solo daily practice into a real, deployed, self-improving system — the same one running psychedluxuries.com today.

What this system actually is

Honesty about scale, because the number is the point.

At the time of writing, the system this course draws from spans thirty-odd code repositories, around a hundred and ten installed skills, eleven connected tool servers, a knowledge vault of several thousand notes, a fleet of named agents with individual memories, and a set of scheduled jobs that run whether or not anyone is awake.

You are not going to build that. You should not try to build that. It was not built in one pass — it accreted, one irritation at a time, over years.

The four layers of the system, and the order they were built in Four stacked layers: the vault of written knowledge at the base, then standing instructions, then agents and skills, then scheduled automation at the top. Each layer rests on the one below it. A side note marks where this course starts. 1 · The written record notes, specs, decisions — the thing everything else reads 2 · Standing instructions CLAUDE.md — what is always true, loaded every session 3 · Skills and agents repeated procedures, given names and memories 4 · Scheduled automation work that runs whether or not anyone is awake each layer only works if the one beneath it is real you start here module 1, one file

The order in that diagram is not a suggestion. Automation resting on nothing is the failure this course spends the most time on — a scheduled job nobody reads the output of, an agent with no memory, a rule written in a file the system never opens. Every layer is only as real as the one beneath it, and the bottom layer is a text file you write yourself in Module 1.

But that number matters for a different reason: it is the honest denominator. Most teaching material about AI agents is written from a demo. This one is written from a system with production traffic, real customers, real money, real outages, and a documented history of things going wrong. When a module tells you a rule, it can also tell you the specific failure that forced the rule to exist — with a date.

What this course does differently — the mistakes are the material

Every module here is built in three layers, in this order:

1. What actually happened. A real incident from the real system. Dated. Specific. Usually embarrassing. An agent that hung for one hour and fifty-six minutes because two of its instructions contradicted each other. A coordination system that reported twenty live sessions when there were two, because it was keyed to the wrong identifier. An automation that reported success for weeks while doing nothing at all, because nobody had ever checked whether it was wired to anything.

2. The same lesson, stated generically. Stripped of the specifics, so it transfers. You are not running this brand; you are running yours. The failure shape is what carries over, not the nouns.

3. The building block. The actual thing you copy and use — the template, the folder structure, the checklist, the skill scaffold. Not "you should have a spec habit." The spec file, with its fields, and where it goes.

A module with only the first layer is a memoir. A module with only the second is a blog post you have already read. The three together are the product.

This matters because of what most courses in this space quietly do: they show you the finished machine and imply it arrived that way. It never arrives that way. The retirement column is more instructive than the roster — the things that got cut, the agents that were never actually wired to anything, the tools that looked essential and turned out to be decoration. You will see those here, by name, with the reasoning that killed them.

Credentials

Where the visual and technical foundation started. High school electives in photography, engineering and design, robotics, Photoshop, and 3D design — the design and engineering thinking behind everything here isn't recent, and it isn't borrowed. Seven-plus years of art and digital design practice since, then the system-building itself: the multi-agent operating system this course teaches, built and run in production.

Seven completed Anthropic Academy certifications — each one a real, publicly verifiable certificate of completion issued by Anthropic, not a self-claimed badge. Module 0 embeds the actual certificates with their public verification links (verify.skilljar.com), so a buyer can confirm every one independently:

CertificationCompletedVerifyPDF
Claude 1012026-07-04verify.skilljar.com/c/rts86yp2vfnhclaude-101.pdf
Claude Code 1012026-07-04verify.skilljar.com/c/sartm6c2oq92claude-code-101.pdf
Claude Code in Action2026-07-10verify.skilljar.com/c/tf8isqenn2d4claude-code-in-action.pdf
Claude Platform 1012026-07-10verify.skilljar.com/c/57pg4udn8e7xclaude-platform-101.pdf
Introduction to Claude Cowork2026-07-04verify.skilljar.com/c/hxwercj7aa6nintro-to-claude-cowork.pdf
AI Fluency for Educators2026-07-10verify.skilljar.com/c/3ye4nzaqne3yai-fluency-for-educators.pdf
AI Fluency: Framework & Foundations (9/10)2026-07-10verify.skilljar.com/c/r5bcu347rb9hai-fluency-framework-foundations.pdf

All seven real certificate PDFs downloaded and filed at the-forge/public/certificates/. Every verify link is a live, public Anthropic-issued URL — a buyer can confirm each independently without taking anyone's word for it.

[Certifier.io accreditation — status pending, added here once live.]

What is borrowed, and from whom

A system this size is not written by one person from nothing, and pretending otherwise would fail the first test this course teaches.

Much of the stack is other people's work, used with gratitude and named plainly: open-source skills, community-built tool servers, published plugins, and cloned repositories that solve problems better than a from-scratch attempt would. Where a module leans on one of those, it says so and names it. Where something was built in-house, it says that instead.

The distinction matters more than it might seem. A course that blurs "I use this" into "I built this" is teaching you to misrepresent your own stack later — and the habit of precise attribution is the same habit that makes the rest of the system trustworthy. If you cannot say honestly where a piece came from, you do not understand your own system well enough to teach it.

This is a living document

THE FORGE is not a finished artifact you bought a frozen copy of. It gets updated — new modules, corrections, new patterns as the system that teaches them keeps evolving. That's the whole thesis of the course applied to the course itself: a system that doesn't improve is a system that's already decaying. Your access includes every update. When something here is wrong, or something better is learned, it gets rewritten — and you get the rewrite.

That is not a marketing line. This very module was rewritten because a review found it was teaching the doctrine without the failures that produced it — which is exactly the flaw the course warns about, sitting in the course's own front page.

The other half of this course

Every module here ends the same way: a teaching, and one simple practice.

Not as a bonus, not as filler at the end — because building a system that runs your work and building the mind that decides what's worth building are the same job. Most people learn the tools and stay exactly where they were. The tools amplify whoever's holding them.

Three things run underneath every module:

Prepared for luxury. Not spending like it. Ready for it — set up, in advance, as though the thing you're building already worked. The system you'll build in module 1 is that posture made literal: you write the spec before there's anything to spec.

You are in control of your reality. In a course about handing work to agents, this is the load-bearing one. The system serves your judgment; it never replaces it. Every rule in here exists because a machine did something confidently wrong and a human caught it.

What persists in the mind becomes your reality. This is also, exactly, how the self-improvement loop works (module 4) — what you write down and return to is what compounds. What you don't, evaporates. The mechanism is identical whether the memory lives in a file or in you.

The building block: your one-page honest assessment

Before module 1, write this. It is one page, it is for you alone, and every later module refers back to it. Copy the block below into a new file and fill in each line honestly — it is deliberately not prose, so there is nowhere to hide a vague answer.

# My honest assessment — <today's date>

## 1. What am I building, and why does it matter to me?
<one honest paragraph. Not a business plan. "I don't know yet, I just
 want to stop losing my own ideas" is a legitimate answer.>

## 2. Where does my discipline actually fail?
<be specific and unkind to yourself — this determines what you build first.
 Useful shapes: I start things and abandon them at 70%. I forget what I
 decided last week and re-decide it. I never write anything down. I write
 everything down and never read it again. I lose whole evenings
 re-explaining context to a tool I already explained it to.>

## 3. What have I already tried, and how did it fail?
<the app you stopped opening, the notebook that stopped mid-January.
 Name the failure MODE, not just the tool — "it needed me to be
 consistent to work" is the answer that shows up here most often.>

## 4. What would I have to see, in ninety days, to call this worth it?
<one observable thing, not "be more organised" — something you could
 point at. A thing I built is live and someone who isn't me has used
 it. I have shipped four weeks in a row. I stopped losing ideas.>

## 5. What am I willing to have the machine hold for me?
<the real question of the whole course. Most people hand over
 reminders and correctly refuse to hand over judgment — but there is a
 large middle: remembering decisions, checking work, catching drift,
 holding the routine. Name what you'd rather not carry yourself.>

Keep it somewhere you will see it again — in the vault you set up in module 1, ideally. You'll point Claude at it, and you'll come back to it more often than you expect. When you finish module 10, read it again. The gap between what you wrote and where you landed is the actual measure of whether this worked.

Before module 1

Confirm all of this before moving on:

  • Claude Code is installed and you can open a session inside a project folder
  • Obsidian is installed and you have created an empty vault (any name, any location — module 1 fills it)
  • Your one-page honest assessment is written and saved somewhere you'll find it
  • You have accepted the premise: the system is not evidence of discipline, it is a substitute for it

That's the whole checklist. Module 1 starts the real work — and it starts, as everything here does, by writing down what you intend before you touch anything.