Episode 01 --- Muse in 7 Minutes
Working YouTube title:
Muse in 7 Minutes --- Init, Branch, Diff, Merge, Push, Clone
Thumbnail thought:
the whole workflow. no cuts.
Target runtime: ~7 minutes
[0:00--0:15] COLD OPEN
[CAMERA --- same terminal, same empty prompt Episode 00 ended on. No recap, no "previously on."]
GABRIEL:
Last time, I asked you to imagine version control that actually understands what you're versioning.
[beat]
Enough imagining.
[TITLE CARD --- fast]
MUSE IN 7 MINUTES
[Music enters. Terminal cursor blinking.]
[0:15--1:00] INIT
[TERMINAL]
$ mkdir hello-muse
$ cd hello-muse
$ muse init
[ENTER.]
✅ Initialized Muse repository in /Users/gabriel/hello-muse/.muse
GABRIEL VO:
That's a real repository. Content-addressed object store, commit DAG, the works. We'll tear it open next episode.
Today we're not stopping to admire the machinery.
[CAMERA]
We're running the whole workflow, start to finish, for real. No cuts, no pre-baked demo repo.
[SCREEN --- stopwatch graphic appears, starts running, stays in corner for the rest of the episode.]
Clock starts now.
[1:00--1:40] FIRST COMMIT
[TERMINAL]
$ cat > hello.py <<'PY'
def greet(name):
return f"Hello, {name}!"
if __name__ == "__main__":
print(greet("world"))
PY
$ muse code add hello.py
$ muse commit -m "Add greet function"
[ENTER.]
[main sha256:1a2b3c...] Add greet function
1 file changed (1 added)
GABRIEL:
Add.
Commit.
Feels exactly like Git, on purpose.
[beat]
The familiarity is the point. You're not learning a new tool from zero. You're finding out how much further the same shape of tool can go.
[1:40--2:20] STATUS, LOG, DIFF
[TERMINAL --- rapid-fire, no narration between commands]
$ muse status
On branch main. Clean.
$ muse log --oneline
sha256:1a2b3c Add greet function
$ muse diff
(nothing — working tree matches HEAD)
GABRIEL VO:
Status. Log. Diff.
The three questions you ask a hundred times a day.
[CAMERA]
They're not going anywhere. Muse just answers them with more than lines when there's more than lines to say.
[2:20--3:10] BRANCH, TWICE
[TERMINAL]
$ muse checkout -b feature/friendlier
[edit hello.py --- change the return string]
- return f"Hello, {name}!"
+ return f"Hey there, {name}!"
$ muse commit -m "Warmer greeting"
$ muse checkout main
$ muse checkout -b feature/farewell
[append to hello.py --- a new, independent function]
+def farewell(name):
+ return f"See you, {name}!"
$ muse commit -m "Add farewell function"
GABRIEL:
Two branches off the same commit.
One changes what the greeting says.
The other adds something that didn't exist before.
[beat]
Completely independent edits to the same file.
[3:10--3:50] DIFF BETWEEN BRANCHES
[TERMINAL]
$ muse diff feature/friendlier feature/farewell
[SCREEN --- structured diff, not a raw patch]
M hello.py
├─ greet: return string modified (friendlier)
└─ farewell: function added (farewell)
GABRIEL VO:
This is the same file on both sides. A line-based tool sees one overlapping mess waiting to happen.
Muse sees two changes that don't actually touch each other.
[CAMERA]
Which means the next step should be boring.
[3:50--4:30] MERGE
[TERMINAL]
$ muse checkout main
$ muse merge feature/friendlier
$ muse merge feature/farewell
[ENTER x2. No conflict markers appear.]
Fast-forward feature/friendlier → main
1 file changed (1 modified)
Merge made by the three-way strategy.
1 file changed (1 modified)
[cat hello.py --- both changes present]
def greet(name):
return f"Hey there, {name}!"
def farewell(name):
return f"See you, {name}!"
if __name__ == "__main__":
print(greet("world"))
GABRIEL:
Both changes. One file. Zero conflicts.
[beat]
Not because I got lucky. Because they never actually collided in the first place, and Muse could tell.
[4:30--5:10] PUSH
[TERMINAL]
$ muse push origin main
[ENTER. Real network call, real progress output.]
✅ Pushed 5 commit(s), 6 object(s) to origin/main
[SCREEN --- MuseHub repo page, live, showing the commits that just landed.]
GABRIEL VO:
That's not a mock server. That's MuseHub, running in production, and that push just happened for real, on camera.
[CAMERA]
We'll get to how the signing and the wire protocol actually work. Later episodes, promise.
Right now I just want you to see the round trip.
[5:10--5:40] CLONE
[TERMINAL --- a different directory]
$ cd /tmp
$ muse clone https://musehub.ai/gabriel/hello-muse
[ENTER.]
✅ Cloned into 'hello-muse' — 5 commit(s), 6 blob(s), domain=code, branch=main
$ cat hello-muse/hello.py
[Output matches, byte for byte, what we just built.]
GABRIEL:
Same repository. Different machine, different directory, could easily be a different person, or a different agent.
[beat]
That's the whole point of a content-addressed object store. It either reconstructs exactly, or it fails loudly. There's no in-between.
[5:40--6:15] SPEEDRUN RECAP
[SCREEN --- stopwatch, still running. Terminal history scrolls fast in a picture-in-picture, replaying everything at high speed.]
GABRIEL VO [fast]:
Init.
Add.
Commit.
Branch.
Branch again.
Independent edits.
Structured diff.
Merge, clean.
Push, real network.
Clone, byte-identical.
[stopwatch stops]
[CAMERA]
That's the entire core workflow. On camera. In real time.
[6:15--6:50] THE POINT
[CAMERA]
None of this required you to know anything about content addressing, Ed25519 signatures, or the six-method domain protocol.
[beat]
That's deliberate.
The primitives from Episode 00 --- commit, branch, diff, merge, push, fetch --- aren't theoretical. They're the exact commands you just watched run, in order, with real output, in under seven minutes.
[ON SCREEN]
IT'S NOT A PITCH. IT'S A CLOCK.
[6:50--7:15] OUT
[TERMINAL --- back in hello-muse, main branch, five commits
deep.]
$ ls .muse
GABRIEL VO:
We built this whole history without once looking at what's actually
sitting inside that .muse directory.
[beat]
Next episode, we tear it open. Objects, snapshots, the commit DAG, every hash --- what's really in there, and why.
[CAMERA.]
See you inside.
[CUT TO BLACK]
musehub.ai
Production Notes
Episode 01 should feel like a demo with the safety net removed. No narration should imply anything was staged, trimmed, or run twice off camera. If a command is going to be shown, it runs, live, in the edit's real time or as close to it as pacing allows.
Opening
Pick up literally where Episode 00 stopped --- same terminal, same
muse init about to run. No "hey everyone, welcome back." The
continuity itself is the hook: last episode ended on a cliffhanger,
this one resolves it in the first fifteen seconds.
The Clock Is a Prop, Not a Gimmick
The on-screen stopwatch starting at INIT and stopping at CLONE is the spine of the episode. It's what makes the title a promise instead of a number. If the real take runs long, cut narration, never cut commands --- the workflow has to stay complete and unbroken.
Show Real Muse Constantly
Every command in this script is real and expected to actually run
this way against a real main branch of a real, disposable
hello-muse repo pushed to a real MuseHub instance. If anything here
doesn't work exactly as written when the demo script is built, fix the
demo, not the script's honesty.
Don't Explain, Demonstrate
This is the one episode in the season with almost no lecture. Episode 00 made the claims. Episode 01's entire job is to cash them. Resist the urge to explain content addressing, signing, or the domain protocol here --- there are whole episodes coming for each of those. Every time the urge to explain hits, cut to the next command instead.
The Seed
The viewer arrives at this episode still a little skeptical:
Okay, but does it actually work, end to end, or is that a highlight reel?
They should leave asking:
Wait --- what's actually in that
.musefolder?
That's Episode 02, and the last shot of this episode should point directly at it.