Ashen Reel Quest

Tracks

1. 01🎯The Bounded Replacement

   0/5 lessons

   Why you build a player at all — and how you stop it becoming a media suite

   Movist already plays everything. So why write a new player? Because Dad didn't need everything — he needed the exact slice he touches every day, joined to Recall's memory, proven on his own media. This track is about the hardest discipline in tool-building: deciding what NOT to build, writing the boundary down, and holding the line when the temptation to add 'just one more feature' shows up.

   Lesson list (5)

   • 01
     Why Build a Player at All?~12 min · bounded-replacement, recall, handoff, product-boundary
   • 02
     Parity Is Behavioral, Not Pixel-Perfect~13 min · bounded-replacement, parity, movist, verification
   • 03
     P0 / P1 / P2 / Never: The Intake Tiers~13 min · bounded-replacement, scope, roadmap, prioritization
   • 04
     The Oracle, Not the Architecture~12 min · bounded-replacement, oracle, movist, reverse-engineering
   • 05
     Prove It on the Media You Actually Own~14 min · bounded-replacement, golden-corpus, testing, honesty

   ✓Quiz · 4 questions→

2. 02⚙️Reuse the Engine

   0/5 lessons

   Playback is the product, so you don't rebuild a decoder — you embed one and own the seam

   Movist gets its format breadth from FFmpeg — decades of codec work no weekend can reproduce. Ashen Reel doesn't try. It embeds libmpv, the same engine family, and spends its own effort on the thin layer that actually matters: the boundary between a battle-tested C engine and a native Swift app. This track is reuse done right — take the depth, own the seam, and never let the borrowed engine make your product's decisions for you.

   Lesson list (5)

   • 01
     Playback Is the Product (So Don't Rebuild It)~13 min · embed-engine, reuse, libmpv, ffmpeg
   • 02
     The Narrow C Boundary~14 min · embed-engine, c-interop, boundary, swift
   • 03
     Render Into a View You Own~14 min · embed-engine, appkit, nsview, rendering
   • 04
     Read Engine Truth, Don't Keep a Shadow~12 min · embed-engine, observed-properties, state, libmpv
   • 05
     One Backend First, No Silent Fallback~12 min · embed-engine, fallback, backend, diagnostics

   ✓Quiz · 4 questions→

3. 03🔑The Handoff Is Identity-Only

   0/5 lessons

   A URL that carries a capability, never a path — and why both sides still check

   The whole reason Ashen Reel exists is a deep link: Recall says 'open this video at this second,' and the app obeys. That link is the most security-sensitive surface in the product, because a link is something a web page can build. This track is about designing a handoff that is powerful enough to be the point of the app and narrow enough that it can't be turned into a weapon — an identity, never a path, checked on both sides.

   Lesson list (5)

   • 01
     A URL That Names a Thing, Not a Place~13 min · identity-handoff, capability-security, url-scheme, design
   • 02
     The Confused Deputy~14 min · identity-handoff, security, confused-deputy, threat-model
   • 03
     The Strict Parser~13 min · identity-handoff, parsing, validation, security
   • 04
     Both Sides Validate~15 min · identity-handoff, defense-in-depth, path-traversal, validation
   • 05
     The Other Door: User Intent Is Its Own Authority~12 min · identity-handoff, authority, design, appkit

   ✓Quiz · 4 questions→

4. 04👁️Observed, Not Assumed

   0/5 lessons

   A command sent is not a state changed — the engine's report is the only truth

   The deepest bug in interactive software is the UI that lies: the button says paused while the video plays, the scrubber sits at 41:00 while the picture is at 40:58. It comes from one habit — treating a command you sent as a fact that happened. This track builds the opposite habit into a player: nothing is true until the engine says it is, a seek isn't done until an observed position proves it, and every control on screen is a mirror of reality rather than a memory of intent.

   Lesson list (5)

   • 01
     A Command Sent Is Not a State Changed~12 min · observed-state, async, optimistic-ui, state
   • 02
     A Seek Is a State Machine, Not a Boolean~14 min · observed-state, state-machine, seek, tolerance
   • 03
     Fast Seek and Exact Seek Are Different Promises~13 min · observed-state, seek, keyframes, ux
   • 04
     Explicit Time Beats Resume~12 min · observed-state, resume, precedence, deep-link
   • 05
     Every Control Is a Mirror~13 min · observed-state, ui, projection, appkit

   ✓Quiz · 4 questions→

5. 05🔒Source Is Sacred

   0/5 lessons

   Read-only playback, four owners, and state you can throw away without losing anything that matters

   A player touches irreplaceable things: a family's only copy of a 2015 birthday, sitting on a NAS. The one promise Ashen Reel can never break is that opening a video leaves the video exactly as it found it. This track is about ownership discipline — knowing which system owns which truth, keeping playback strictly read-only, and designing local state so disposable that losing all of it costs nothing an archive would miss.

   Lesson list (5)

   • 01
     Four Owners, One Sentence Each~12 min · source-immutable, ownership, architecture, boundaries
   • 02
     Read-Only Means Read-Only (and You Prove It)~13 min · source-immutable, read-only, integrity, verification
   • 03
     Recoverable Convenience Is Not Archive Truth~12 min · source-immutable, state, recovery, sqlite
   • 04
     Project, Don't Copy~13 min · source-immutable, projection, recall, cqrs
   • 05
     Offline Is Not the Same as Gone~12 min · source-immutable, offline, error-handling, resilience

   ✓Quiz · 4 questions→

6. 06📦Ship the Whole Thing

   0/5 lessons

   swift build isn't deployment; a signed, self-contained bundle that runs on a Mac you've never seen

   There's a canyon between 'it runs on my machine' and 'it's installed and working on the target.' For a native app that embeds a big C library, that canyon is full of dylibs, signatures, and paths that quietly point at your development setup. This track crosses it: bundle and sign the entire dependency closure, make a deliberate and defended choice about the sandbox, and build a doctor that proves the installed artifact is real — because a green build is a promise, and only the doctor is proof.

   Lesson list (5)

   • 01
     swift build Is Not Deployment Proof~12 min · self-contained, deployment, dylib, build
   • 02
     Bundle and Sign the Whole Closure~14 min · self-contained, dylib, codesign, bundling
   • 03
     Opting Out of the Sandbox, On Purpose and With a Net~14 min · self-contained, sandbox, security, tradeoff
   • 04
     The Doctor: Verify the Installed Artifact~12 min · self-contained, verification, codesign, deployment
   • 05
     Six Version Domains That Move Alone~13 min · self-contained, versioning, compatibility, architecture

   ✓Quiz · 4 questions→

7. 07🤝The Sidekick Without a Brain

   0/5 lessons

   How a player gets a Pippa without becoming a Pippa

   Ashen Reel has a Pippa Sidekick — a pane where you can ask about the moment you're watching. The temptation, the instant you add an AI pane, is to give it 'just a little' local intelligence: a cached model, a private conversation store, a small brain of its own. This track is about refusing that temptation completely. The player projects, binds, and asks; it never decides. Every conversation is a canonical cwkPippa conversation, context travels with each turn, and the app that plays video stays an app that plays video.

   Lesson list (5)

   • 01
     No Parallel Pippa~12 min · sidekick, boundaries, client-surface, architecture
   • 02
     Bind Per Identity, Not Per Session~13 min · sidekick, binding, conversation, idempotency
   • 03
     Context Travels With the Turn~13 min · sidekick, stateless, context, timeouts
   • 04
     Reference the Moment, Don't Ship It~12 min · sidekick, reference, handoff, recall
   • 05
     Ship No Call to an Endpoint That Doesn't Exist~12 min · sidekick, contracts, restraint, api-design

   ✓Quiz · 4 questions→

8. 08🎬The Making Of

   0/4 lessons

   How the player was actually built — and the discipline you can take anywhere

   The last track steps back from the code to the craft. Ashen Reel wasn't built by starting to type; it was built by deciding what could never change before the first brick, proving parity on real media before claiming it, and defining 'done' as an installed artifact on a real machine rather than a green build. This is the making-of — the small set of habits that turned a bounded idea into the player that finally retired Movist, and that you can carry into anything you build next.

   Lesson list (4)

   • 01
     Decisions Before the First Brick~12 min · epilogue, architecture, planning, decisions
   • 02
     What 'Done' Means: The Cutover Gate~13 min · epilogue, definition-of-done, acceptance, cutover
   • 03
     A Player in a Family~13 min · epilogue, architecture, boundaries, unix-philosophy
   • 04
     The 5% View, and Where to Go Next~14 min · epilogue, philosophy, restraint, 5-percent-view

   ✓Quiz · 3 questions→