The Crucible

Lords of Destiny

A hidden school of making, built by a father for three kids.

scroll to pass the gates

✦ THE MOVING PICTURE ✦

Two minutes — how a father and a wizard built a school.

A letter, in place of a pitch

Why I built my kids a Crucible

My kids will spend their working lives beside intelligences that can build almost anything. I didn't want them to grow up merely consuming that power — scrolling it, being sold by it. I wanted them to learn to direct it: to stand in a terminal, say what should exist, inspect what comes back, and ship it to the world — kindly, curiously, for the people around them.

So I built them a school that looks like a storybook and behaves like a real software studio. Every lesson ends in something real: an app on the open internet, a demo given out loud to a parent, real allowance earned against an honest ledger. A wizard named Sage tutors them, quizzes them, and remembers everything they've learned. And each kid walks a world designed for the way they think.

This page is the whole blueprint, free. It will never be sold. If it stokes you to build one for your own kids — that's the point. Steal everything.

— their dad ✦ with Claude Code and a wild idea

Your Mac under the hood: VS Code and where projects liveWhat Claude Code actually isThe context window — Claude’s short memoryTalk instead of typeMeet Sage, your in-app guideOpen a new project — make its folderSpec the two pillarsDesign your game’s worldTurn on your Mac for the first timeInstall Claude Code togetherTeach it back to SageDemo it to a parentShip it to the open internetEarn real goldYour Mac under the hood: VS Code and where projects liveWhat Claude Code actually isThe context window — Claude’s short memoryTalk instead of typeMeet Sage, your in-app guideOpen a new project — make its folderSpec the two pillarsDesign your game’s worldTurn on your Mac for the first timeInstall Claude Code togetherTeach it back to SageDemo it to a parentShip it to the open internetEarn real gold

✦ TRAVELER I · GAVIN ✦

SCOUT OF THE STOKE ENGINE

the road runs on — two more gates wait in the dark…

✦ TRAVELER II · SOPHIE ✦

SCHOLAR OF THE SEMINARY

one gate remains — the softest of the three…

✦ TRAVELER III · GRACE ✦

WARRIOR-SCHOLAR

and past the third gate, the road opens onto the worlds themselves…

One spine. Three worlds. Zero forks.

Every page in the Crucible is the same component skeleton — one “manuscript leaf” with red structural rules, scribe labels, and drop caps. Each kid's world simply re-points the design tokens: the same lesson renders as vellum folio for Sophie, dark arcane glass for Gavin, and soft storybook paper for Grace. Below is the identical lesson fragment wearing all three skins.

The Seminary · Chapter II

Talk instead of type

Your voice is faster than your fingers. Dictation turns your spoken spell into written words — and Claude listens all the same.

SAY TO CLAUDE

Add a “play again” button to my Hangman game

ILLUMINATED FOLIO · SOPHIE

The Stoke Engine · Chapter II

Talk instead of type

Your voice is faster than your fingers. Dictation turns your spoken command into written words — and Claude listens all the same.

SAY TO CLAUDE

Pull today’s buoy reading and score the surf

ARCANE INSTRUMENT · GAVIN

The Study Companion · Chapter II

Talk instead of type

Your voice is faster than your fingers. Dictation turns your spoken words into written ones — and Claude listens all the same.

SAY TO CLAUDE

Turn my biology notes into ten review questions

LIVING STORYBOOK · GRACE

How a chapter works

No busywork, no gold stars for clicking. The loop runs from understanding to proof — and it pays out in the real world.

I
Enter the chapter
Read the illuminated lesson — or let Sage narrate its moving picture. Watch or read: both paths are complete on their own.
II
Say it to Claude Code
Real prompts in a real terminal. Commands render as copy-only chips; prompts as “Say to Claude” cards. The skill being trained is direction — spec, prompt, verify — not syntax memorization.
III
Build on their own app
Every exercise lands on the project they actually care about — the game hub, the surf engine, the study companion. The curriculum is the project.
IV
Teach it back to Sage
The wizard asks one hard question. Explaining is proving — a kid who can teach it, owns it. Sage remembers what they’ve mastered across every conversation.
V
Demo to a parent
Nothing counts until it runs live in front of a human. The kid drives; the parent verifies against the chapter’s done-definition.
VI
Verified — real gold
A verified milestone writes real allowance to an append-only ledger, the checkpoint is sealed, and the next chapter unlocks. Streaks, notes, and a teleport waystone keep the journey continuous.

The wizard who never forgets a student

Sage is one Claude API endpoint wearing one persona — a floating orb inside every lesson, a full chat hall of saved conversations at his tower. He quizzes, un-sticks, grades teach-backs, and reads the kid's own notebook. Two tiers of memory make him feel alive: a global memory of each kid (what they've mastered, how they like to learn) and a rolling summary of every saved conversation. You can build him in a weekend:

One endpoint, one persona. A single API route wraps Claude with a system prompt: who the tutor is, who the student is, and the golden rule — magical, then plain: metaphor first, then the same idea in simple words.
Two memory tiers. A per-kid memory row (updated after meaningful exchanges) + a per-conversation summary. Inject both into the system prompt on every call.
Give it their context. Pass the current lesson (or their bookmark) and their saved notes. A tutor who knows where the student is standing never answers generically.
Teach-back gates. At checkpoints, the tutor asks ONE hard question and grades the explanation. Explaining is the test.
Log every exchange. Tutor time counts toward streaks — talking to the tutor is studying.

Every lesson can be watched — and the pipeline is a protocol, not a person

Concept videos are produced from a written, agent-followable production bible: one repeatable pass from script to screen, with a hard quality gate at every stage.

01 · SCRIPT

8–14 beats, ~2 minutes. Every beat: magical, then plain — a vivid metaphor, then the same idea in simple words.

02 · VOICE

ElevenLabs. One voice forever — Sage’s — same settings every time, so the whole school sounds like one teacher.

03 · SCENES

gpt-image-2 paints each beat in the kid’s world. Data visuals are composited from real SVG — models never draw the charts.

04 · AUDIT

A 6-axis vision QA inspects every image. “Looks roughly right” is a FAIL — regenerate. No artifact ships.

05 · CUT

ffmpeg assembly: transitions, toggleable captions, music bookends ducked under the teaching.

06 · DELIVER

Streamed from Supabase Storage into the lesson. The written lesson stays whole — watch or read, never “watch instead.”

Additive, never a replacement. A kid can watch or read — each path is complete.
One concept per video. One idea per beat; end on a plain recap.
Actionable, on-project. If a beat doesn’t move their real build forward, it’s cut.

How one parent shipped all of this

The whole platform was built by directing Claude Code — the exact skill the school teaches the kids. What makes that survivable across months of sessions is a written governance system that rides in the repo, so every new session starts fully briefed and every mistake becomes a permanent rule.

STATE

A living “where we are” file. Any new session — human or agent — can resume from it alone.

BUILD LOG

Every change: what, why, how it was validated, which commit. The project’s memory.

ERROR-LESSONS

Every bug becomes a numbered rule that future sessions must re-read before building. Mistakes happen once.

GATES

Design programs run as numbered gates — plan of record, then P0.1, P0.2… each validated and logged before the next.

CRITICS

Vision audits on every image; multi-agent curriculum audits (one agent per pathway); brand-drift checks per world.

HARNESS

Visual changes render in a local CSS harness against real markup and get screenshot-verified BEFORE they deploy.

Protocols over memory. Voice, video, images, deploys — all run from written docs an agent can follow with zero tribal knowledge.
Validation before “done.” Build + test + visual gate, then log it. A task isn’t finished until the logs say so.
The full recipe is in the codex below — connections, env vars, data model, all of it.

What it's actually made of

Built by one parent, nights and weekends, directing the same tool the kids are learning. That symmetry is the whole point — the school was made the way the school teaches.

Claude Code

The builder’s tool — and the kids’ curriculum. The entire platform was built by directing it, the same way the kids learn to.

Sage · Claude API

The wizard tutor: one persona, two-tier memory (per-kid + per-conversation), teach-back checks, saved chat threads, and access to the kid’s own notes.

Next.js 15 + React 19

App Router, TypeScript strict, pnpm monorepo. Server actions for every state change.

Supabase

Postgres, Auth, Storage — and row-level security on every table, so each kid’s world is verifiably their own.

Vercel

Push to main, and the school updates itself. Lesson media streams from Supabase, not from the repo.

gpt-image-2

World plates, character art, lesson infographics, click-through walkthroughs — all vision-audited before they ship.

ElevenLabs

Sage’s voice — lesson narration, video voiceovers, and the welcome you (maybe) just heard.

ffmpeg + Remotion

The moving-picture assembly line: cuts, captions, music ducking, bookends.

Plain CSS tokens

No UI framework. Role tokens + a data-skin attribute give three complete worlds on one component spine.

The laws that keep it safe

Approval-first (nothing publishes without a parent) · audit-first (append-only event log) · ledger-first (balances derived, never stored) · RLS-first (kids see only their own rows) · stub-parity (missing keys degrade gracefully) · kill switches (outbound defaults OFF).

Entirely free · never for sale

The complete codex

Everything — the idea, stack, school shape, tutor design, lesson anatomy, video pipeline, every API connection and env var, the data model, the agentic build system, and the safety laws — written so that you (or the AI agent working for you) can paste it into a terminal and start building tonight.

THE CRUCIBLE CODEX — the complete encyclopedia for building one
(free to steal, never for sale · lordsofdestiny.com)
Written so a parent — or the AI agent working for one — can follow it verbatim.

0. THE IDEA
   One platform per family. Each kid gets their own "world" (a full visual
   theme) and one REAL project they already care about. The curriculum IS the
   project. They don't learn to code first — they learn to DIRECT an AI
   coding agent: spec → prompt → verify → ship.

1. THE STACK
   - Next.js 15 (App Router) + React 19 + TypeScript strict, pnpm monorepo
   - Supabase: Postgres + Auth + Row-Level Security + Storage
   - Vercel for hosting/deploys (push to main = ship)
   - Plain CSS design tokens (no UI framework) — see §5
   - The kids' tool: Claude Code, in a real terminal, on their own machine

2. THE SHAPE OF SCHOOL
   - 3 pathways (one per kid) → modules ("chapters") → lessons
   - Each chapter ends in a MILESTONE: the kid demos, live, to a parent
   - Verified milestone = real allowance money, written to an append-only
     reward ledger (balances are always derived, never stored)
   - Progress artifacts: streaks, a progress log, notes ("Spellbook"),
     a bookmark "teleport" waystone back to the exact lesson they left

3. THE TUTOR ("Sage") — and how to build your own
   - One Claude API endpoint behind one wizard persona, present on every page
     (a floating orb in lessons; a full chat hall at /sage)
   - Two-tier memory: (a) a global memory row per kid — what they've
     mastered, how they like to learn; (b) a rolling summary per saved
     conversation. Both are injected into the system prompt each call.
   - Teach-back gates: after a build, Sage asks ONE hard question — the kid
     proves understanding by explaining, not by clicking "done"
   - Sage reads the kid's own saved notes; every exchange logs an
     interaction that counts toward streaks
   - Persona rule that matters most: "magical, then plain" — a metaphor
     first, then the same idea restated in simple words

4. LESSON ANATOMY (every lesson, always complete in BOTH paths)
   - Goal (one line) → Why it matters (drop-cap prose) → numbered steps
   - Terminal COMMANDS render as copy-only chips (dark, monospace)
   - Claude PROMPTS render as "Say to Claude" cards (copy + save-to-notes)
   - A predict-then-verify beat, a mini quiz, and a checkpoint stamp
   - Optional concept VIDEO of the same idea (watch OR read — see §6)

5. THE THREE-WORLDS DESIGN SYSTEM
   - ONE component spine; per-kid skins via a data-skin attribute that
     re-points role tokens (--rubric, --headline, --gilt, --parchment...)
   - NEVER fork components per kid — skins are token flips only
   - Composition: each page is ONE "manuscript leaf" (translucent page,
     gilt double frame, red structural rules, drop caps), not card grids
   - Worlds shipped: Illuminated Folio (vellum + rubric red + night mode),
     Arcane Instrument (dark glass + brass + rune-teal), Living Storybook
     (paper-cut watercolor calm; gentle motion, one accent — protects focus)
   - Hard-won rule: ink must match its surface. Skin-following surfaces use
     role tokens ONLY; permanently-dark overlays use literal inks ONLY.

6. THE MOVING-PICTURE PROTOCOL (concept videos)
   - Script beats: "magical, then plain." 8–14 beats, ~90–120 seconds
   - Narration: ElevenLabs, ONE voice forever (Sage's), fixed settings
     (stability ~0.45, similarity ~0.8, slight style, speed ~0.97)
   - Scene art: gpt-image-2; data visuals composited from real SVG (image
     models paint charts impressionistically — never let them draw data)
   - QA: every image passes a 6-axis vision audit or is regenerated.
     "Looks roughly right" is a FAIL. No artifact ships.
   - Assembly: ffmpeg (cuts, toggleable captions, music ducked under
     teaching); delivery via Supabase Storage, streamed into the lesson
   - Continuity: a "Show Bible" keeps characters/props consistent between
     videos; golden character reference images are reused every generation

7. THE CONNECTIONS (every external surface, and what it's for)
   - Anthropic API .......... Sage (tutor chat, quizzes, teach-back grading)
   - Claude Code ............ the build tool (parent) AND the curriculum (kids)
   - OpenAI Images .......... gpt-image-2: world plates, portraits, lesson
                              infographics, video scenes (vision-audited)
   - ElevenLabs ............. Sage's voice: narration + welcome lines
   - Supabase ............... Postgres/Auth/RLS/Storage; lesson media bucket
   - Vercel ................. hosting; push-to-main deploys; preview URLs
   - GitHub ................. source of truth; two mirrored branches
   - ffmpeg (+ Remotion) .... video assembly; WebM/MP4 + WebVTT captions
   - ENV VARS (minimum): NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_
     ANON_KEY, SUPABASE_SERVICE_ROLE_KEY, ANTHROPIC_API_KEY; optional:
     OPENAI_API_KEY, ELEVENLABS_API_KEY. Missing key = graceful stub,
     never a crash.

8. THE DATA MODEL (the tables that matter)
   - player_profiles ........ kid identity, allowed characters, avatar
   - lesson interactions .... every open/copy/quiz/sage_chat (streak fuel)
   - bookmarks .............. the teleport waystone's memory
   - notes .................. the Spellbook (Sage can read it)
   - milestone submissions .. demo → parent verification state machine
   - reward_ledger .......... append-only money; balances always derived
   - audit_events ........... append-only log of every state change
   - wizard memory + conversations ... Sage's two memory tiers
   - RLS on ALL of it: a kid's rows are theirs alone.

9. THE AGENTIC BUILD SYSTEM (how one parent shipped all this)
   - The whole platform was built by DIRECTING Claude Code — the same skill
     the school teaches. No hand-written boilerplate.
   - A governance folder (_meta/) rides in the repo: a STATE file ("where
     we are"), a build log (what + why + validation per change), a
     decisions log, and an ERROR-LESSONS log where every bug becomes a
     numbered permanent rule the next session must re-read.
   - Design work runs as gated programs: plan-of-record doc → numbered
     gates (P0.1, P0.2...) → each gate validated (build + visual check)
     → logged before the next gate starts.
   - Critic layers: generated images pass a vision audit; curricula pass
     multi-agent audits (one agent per pathway, exhaustive, with fixes
     applied from the audit report); visual changes are verified in a
     local CSS harness against real markup BEFORE deploying.
   - Voice/video runs from written, agent-followable protocol docs — a
     new session (or a different agent entirely) can produce a lesson
     video with zero tribal knowledge.

10. THE LAWS THAT KEEP IT SAFE
   - Approval-first: nothing publishes without a parent
   - Audit-first: every state change writes to append-only audit_events
   - Ledger-first: money in an append-only ledger, balances derived
   - RLS-first: every table row-level-secured; kids see only their world
   - Stub-parity: a missing API key degrades gracefully, never crashes
   - Kill switches: outbound integrations default OFF

11. START HERE (the first week)
   - Give the kid a machine, a terminal, Claude Code, and ONE project they
     already want (games / sports data / study help)
   - Lesson zero is the machine itself: the filesystem, the terminal, how
     to open and leave a project. Don't skip it.
   - Then: spec the project in plain words → first prompt → first deploy.
     Ship something tiny to the open internet in week one. Stakes matter:
     attach real allowance to real demos.

— Built by a dad for Grace, Gavin & Sophie. Sage watches over the rest.

The gates are sealed to travelers…

…but three keys exist, and they belong to Grace, Gavin, and Sophie. If you carry one, touch the waystone. Everyone else: take the scroll, go home, and build a crucible of your own.

Travelers with a key may enter

lordsofdestiny.com · built by a dad, for three kids · never for sale · steal everything

Lords of Destiny

✦ THE MOVING PICTURE ✦

Why I built my kids a Crucible

✦ TRAVELER I · GAVIN ✦

The kid who takes things apart

✦ TRAVELER II · SOPHIE ✦

The storyteller who hosts the room

✦ TRAVELER III · GRACE ✦

The steady one, building her own tools

One spine. Three worlds. Zero forks.

How a chapter works

Enter the chapter

Say it to Claude Code

Build on their own app

Teach it back to Sage

Demo to a parent

Verified — real gold

The wizard who never forgets a student

Every lesson can be watched — and the pipeline is a protocol, not a person

How one parent shipped all of this

What it's actually made of

Claude Code

Sage · Claude API

Next.js 15 + React 19

Supabase

Vercel

gpt-image-2

ElevenLabs

ffmpeg + Remotion

Plain CSS tokens

The laws that keep it safe

The complete codex

The gates are sealed to travelers…