Video summary

Geoffrey Litt: Dynamic Documents as Personal Software

Main summary

Key takeaways

Technology

“Dynamic Documents as Personal Software” (Geoffrey Litt)

Geoffrey Litt argues that the next leap in software accessibility and usefulness comes from dynamic documents—documents that combine data, computation, and interactive views—rather than treating software as isolated “apps” with fixed functionality.

He frames the talk as a long personal research “rabbit hole,” moving through live programming, interactive code understanding, dynamic document prototypes, and finally product work at Notion.

Core ideas and technological concepts

1) Dynamic documents as “personal software”

Documents become a single flexible medium where users can assemble capabilities:

  • Structured data (e.g., named “mentions” in an outline)
  • Computation (formulas / spreadsheet-like logic)
  • Views (maps, tables, calendars, etc.)

This contrasts with apps, which bundle those concepts into a rigid tool made by someone else—often forcing users into copy/paste and manual coordination across separate tools.

2) Live programming / code-data co-visibility (Margin Notes)

Litt describes Margin Notes, a project aimed at helping people understand code by showing runtime examples alongside source:

  • When reading code, you can click to see the return value from previous runs
  • You can inspect relevant runtime state

Implementation concept (Ruby):

  • Uses Ruby’s TracePoint API to hook method call/return events
  • Stores execution snapshots and renders a UI to explore them later

Operational/testing angle:

  • To avoid recording in production, it can record results from running the test suite
  • Example outcome: it helped find incorrect or missing docstrings by observing what actually occurred in tests

Packaging/review feedback:

  • The work was submitted to an academic “Live Programming” workshop
  • It was initially rejected, then accepted after corrections—highlighting the value of serious expert reviews

3) Embark: a document-based travel “app” rebuilt from primitives

Litt then presents Embark (with Ink & Switch) as a demonstration of dynamic-document primitives.

Conceptual goal: make a note/outliner dynamic so it can act like a travel planner.

He adds three primitives to an outliner:

  1. Mentions: embed structured data inside the outline (e.g., places)
  2. Formulas: computations inferred from document context (spreadsheet-like)
  3. Views: UI layers bound to outline nodes/subtrees

Examples:

  • Mention a place → clicking triggers import of structured info from Google Maps
  • Add a map view for the trip or for each day → it pulls in relevant mentions based on outline hierarchy
  • Use subtree properties (e.g., color) that propagate into view rendering (e.g., pin colors)

Weather planning:

  • A “Weather” button suggests a formula based on context like day and location in the outline
  • It repeats computation across days

Routing and cost calculations:

  • “From X to Y” generates candidate formulas (drive/train/walk options)
  • Route distance feeds further formulas (fuel costs, per-person cost)

Cross-view coordination:

  • A calendar view can compare event time windows with hourly weather produced by formulas

Key product/design claim: Embark succeeds because the travel planning surface is already a document that users naturally write in; the dynamic system layers computation + views onto that same context.

4) “Notion HTML blocks” and AI-generated interactive artifacts

In the final “Notion” chapter, Litt discusses how the direction shows up in product work:

  • Notion can host dynamic content via HTML blocks created/filled by coding agents

Demo concept: “explain diff”

  • An AI agent produces a dynamic explanatory document, not just text
  • The document teaches:
    • background context (e.g., game engine),
    • coordinate systems / key concepts,
    • intuition-first explanations,
    • interactive figures (e.g., sliders for isometric tilt; occlusion behavior)

Underlying principle:

  • Interactive embeds alongside editable text enable direct manipulation and collaboration, rather than relying on a monolithic HTML blob.

5) Learning/engagement mechanisms inside documents (quizzes)

To address the fact that people often don’t fully learn from reading alone, Litt describes adding:

  • Space-repetition-style quizzes to code explanations (as interactive HTML content)
  • A personal rule: must pass a quiz before merging code to prevent shallow understanding

6) Shared state across interactive parts (alpha custom blocks)

Litt emphasizes an architectural distinction:

  • Simple embeds/blocks may be “local,” but his broader vision needs multiple UIs coordinating on shared state stored in a database
  • He notes this is still in alpha, but it enables more “app-like” behavior through document composition

Multiplayer/collaboration concept:

  • He references earlier research (Riffle) where UI state is stored in a shared database, enabling synchronized multi-user interaction
  • He also mentions a strategy for switching between local vs shared state by moving it into the shared model

Reviews / guides / tutorials mentioned

  • Live Programming workshop review process

    • Formal expert critiques (long emails + substantial reading lists)
    • Valuable feedback even when initially rejected

  • “How to take a rabbit hole seriously” reflections

    • Practical guidance (not a step-by-step tutorial)
    • Emphasizes:
      • optimizing for curiosity / interesting opportunities
      • relying on community
      • recognizing different “shapes” of organizations (academia, independent labs, RC)

Product direction and constraints

  • He answers questions about scope:

    • The general medium long-term goal is broad, but start narrow
    • Embark is framed as “travel” to constrain and validate

  • He identifies a major barrier: low learning floor

    • Dynamic document systems risk becoming like Vim/advanced primitives: powerful, but hard to start
    • He argues for onboarding-like approaches (layered wins, progressive disclosure)

  • Spreadsheets as the success case

    • Immediate value (type numbers → instant win)
    • Then gradual learning of formulas

Key speakers / sources

Main speaker

  • Geoffrey Litt

Referenced collaborators / researchers

  • Alex Warth (directional programming)
  • Glenn (flow sheets; fuzzy set; interactive README concept)
  • Daniel Jackson (MIT; “The Essence of Software”; PhD advisor)
  • Paul Santoleri and Alex Obernauer (Embark collaborators at Ink & Switch)
  • Ink & Switch team (including named partners above)
  • Steve Krouse (live programming community; now Valtown mentioned)
  • Josh Horowitz (mentioned)

External systems referenced

  • TracePoint (Ruby interpreter API)
  • HyperCard
  • Alan Kay quote about drawing people into customizing tools
  • Anima Tsushak / Michael Nielsen (quiz-based learning / active recall concepts)

Product/source mentioned

  • Notion, including:
    • “Notion HTML blocks”
    • custom blocks (noted as alpha)

Original video