Share the Graph, Not the Deck

It's Not About Instant Generation

The key insight isn't that you can generate a deck instantly — it's that a 5-minute conversation with an agent is now enough to produce a full presentation. You talk through the idea, riff on structure, and the document just falls out of the conversation.

The artifact is a byproduct. The thinking is the work, and 5 minutes of thinking is often enough. This can happen often — you can have these conversations daily.

The Old Way: Linear Decks

Intro → Concept A → Concept B → Demo → Summary

Hours of work per deck. Locked into one sequence. Can't reuse pieces.

Move Up the Stack

When a conversation produces a presentation, you stop thinking about making decks and start thinking about the structure above them. Just like when coding got fast, you started thinking about architecture.

The structure above presentations is the dependency graph of the knowledge they contain.

The New Way: Knowledge Graphs

When you can have a 5-minute conversation and get a presentation, you accumulate them fast. The question becomes: how do these relate? Share the graph of related presentations — with explicit dependencies between them.

Each node is a standalone presentation. The graph shows how they compose.

Why This Matters

Every node can be taught by itself and reused in other flows. The "CLI Basics" node serves your curriculum but also someone else's completely different one.

When you share, you make this clear by sharing the graph — so people see both the piece and where it fits.

Key Property: Reusability

The "Git" node appears in your coding curriculum, but also in someone else's "Open Source Contribution" curriculum, and in another person's "Technical Writing" flow.

The node doesn't belong to one graph. It lives at the intersection of many. That's the whole point.

Why This Structure Helps

People always say I'm a bit scattered — multiple ideas running in parallel, connecting things across domains. That's not a bug, it's a graph. The problem was never the thinking — it was that linear formats (decks, docs, emails) can't represent parallel threads with dependencies.

A knowledge graph makes the structure explicit. Instead of flattening 5 concurrent ideas into a single sequence, you show them as what they are: nodes with edges. People can enter anywhere, follow dependencies, and build their own path.

This site — p10q.com — is itself a live DAG. About is the foundation node at the bottom, Learning Resources sits on top, and everything else branches upward. Click any node on the home page and preview it without leaving the graph. The structure is the interface.

Who Benefits

The Graph Overlay Handshake

When you pass knowledge to someone, it's a "graph overlay" — your graph laid on top of theirs. The overlap is where you already agree. The new edges are the knowledge transfer.

your_graph ∪ my_graph → shared_understanding
Δ(new_nodes) → the actual knowledge transferred

Browsing Common Overlaps

In the future, knowledge sharing is mostly about browsing overlapping graphs.

Could This Become a Norm?

Imagine if sharing knowledge meant sending a graph overlay. Not "here's my 40-slide deck" but "here's my knowledge graph — it shares 6 nodes with yours, here are the 3 new ones."

This works for teams (onboarding = "here's the team graph, you already know these nodes"), courses (a syllabus is a DAG, not a list), and any knowledge transfer.

The format is simple: a JSON file with nodes and edges. The rendering is up to the reader. The structure is the protocol. Subscribe to someone's graph and receive only the delta — new nodes, updated nodes, new edges. Respect people's attention.

Versioned Knowledge

Every graph publishes a feed.json with a version number and per-node update timestamps. When something changes, the version increments.

{ "version": 3, "lastUpdated": "2026-02-19",
  "nodes": [
    { "id": "pi_is_all_you_need",
      "updated": "2026-02-01" },
    { "id": "graph_overlays", ★ new
      "updated": "2026-02-19" }
  ] }

The Delta Email

A subscriber gets a daily (or weekly) diff showing:

Not "here's my whole blog again" — just the Δ. Respect people's attention.

The Stack Keeps Moving Up

Each layer becomes trivial, so you think about the layer above it.

Implementation

It's simple enough to build today:

This site (p10q.com) already does steps 1–2. The subscription layer is next — a Lambda that diffs feed.json versions and sends subscribers just the Δ: what's new, what changed, what got connected.