Concepts guide: concept map and sequence

Rufus's review of v2 (15 Oct): it puts everything up front (TL;DR covers git, links to the data model), and doesn't build up concepts one at a time. This page works out the concepts, what depends on what, the order he dictated them in, the possible paths, and the one linear path to write. Source: the dictation.

Decided by Rufus: three parts. Part 1 is the physical office, worked all the way through. Part 2 maps it to digital in general (publishable beyond Life Itself). Part 3 is how Life Itself does it. Pictures for every step, ASCII first, later isometric SVG.

1. Concept inventory

Reference strand

• Sheet: a piece of paper with something written on it. A plan, a contract, a guide.
• Folder: sheets about one thing kept together. One folder per project, labelled.
• Cabinet: many folders, in labelled drawers, for one organisation or area.
• More cabinets: a second cabinet because there's a second area (Operations, Marketing) or because the first is full.
• Rooms: the organisation outgrows one room; teams move into their own rooms.
• Where cabinets go: central (long walks), copies (they drift), or with the team.
• Pointer: a sheet saying "this exists, it's over there", holding no content itself.
• Splitting next door: a team that grows moves out (the podcast leaves Media House). Buildings: extreme, only mention.

Task strand

• Post-it: a small note of something to do. Contrast with the sheet: two kinds of material, reference and tasks.
• Board: post-its go on a wall where people see and move them, not in folders.
• Stacking: a big post-it with smaller ones under it.
• Folder points to board: a project has a folder and post-its; the folder says where its post-its are.

Working

• Drafting table: making a document is messy (Sharpies, scraps, talk); when there's a result, file a checkpoint.
• Recipe books: rules and templates on the wall for how we keep the cabinets.

Digital (Part 2) and Life Itself (Part 3) are listed in the path below.

2. Dependencies

 Sheet ──▶ Folder ──▶ Cabinet ──▶ More cabinets ──▶ Rooms ──▶ Where cabinets go ──▶ Pointer
   │          │                                       │                               │
   │          └──────────────┐                        └──▶ Splitting next door        │
   ▼                         ▼                                                        │
 Post-it ──▶ Board ──▶ Folder points to board ◀───────────────────────────────────────┘
               │          (a pointer, small form)
               └──▶ Stacking

 Sheet + Cabinet ──▶ Drafting table          Cabinet ──▶ Recipe books

The pointer can be introduced in either of two places: as the folder's note about its post-its (small, early), or as the answer to "where do the cabinets go" (big, later). Whichever comes first, the other reinforces it.

3. The order Rufus dictated

1. Two kinds of material: post-its (tasks) and documents (reference); post-its stack.
2. Rooms (departments), maybe nested.
3. Filing cabinets in rooms; post-its on a board.
4. Where do cabinets go? Central vs in the room; copies drift; the pointer.
5. The project's manila folder, with a note saying where its post-its are.
6. More levels can always be added.
7. Digital: Drive and disk folders; a repo is a cabinet; one repo per area; split when too big (also for AI).
8. Git: sync, history, bundled changes; good UI matters less with AI.
9. (Second dictation) Drafting table vs filed checkpoint; the AI needs the cabinet; AGENTS.md; skills as recipes.

Good: the metaphor is complete before any tool appears, and git comes last. Hard for a learner: it starts with an abstract split (two kinds of material) and the biggest unit (rooms) before the smallest (the folder), so the folder arrives after the problem that needs it.

4. Possible paths

5. Recommendation: D, with post-its after the cabinets and before the rooms

Cross-checked by an independent agent (Fable 5.1) given the same brief: it reached the same path. Taken from its version: post-it, board and stacking as one step; the overview problem and the pointer as two steps, with the pointer as the climax of Part 1; splitting next door together with the rooms, so the Podcast room exists when the pointer needs it; recipe books closing Part 1 as the hook for AGENTS.md and skills.

The story: a small organisation grows, and its office grows with it. Each step adds one thing to the same picture. Post-its arrive once the one-room office has its cabinets, at the point where people need to share what's to be done. That way, when the office outgrows one room, both cabinet and board are already there and move together, and the pointer is the climax.

Why post-its there and not earlier: the first three steps stay on one simple idea (paper and where it goes). Why not later: if rooms come first, every room has to be redrawn when boards arrive.

Part 1: the office

Part 2: the digital office (general)

Part 3: how Life Itself does it

Opening: one or two lines saying what the guide is ("how to organise shared work, explained with an old-fashioned office, then mapped to digital tools"). No summary of every concept, no links to rules docs.

6. Open choices

• Post-its after the cabinets (recommended) or after the rooms (path B)?
• The pointer: shown small at step 6 (the folder's note) and named at step 9 (recommended), or only at step 9?
• Drafting table in Part 1 (recommended, it's still metaphor) or only in Part 2?
• The AI in Part 2 (recommended, it's general) or Part 3?

Appendix: Rufus's amendments for after the v3 draft (15 Oct)

From Rufus's review of the sequence map. He said the current sequence can ship first; fold these in after the draft.

• Map at the top. A map like the sequence diagram helps readers see where they're going. Show the spine running down the page (1, 2, 3, …), with 10 and 11 as side branches.
• 10 and 11 are extras. The drafting table and recipe books are side points, a kind of bonus: you don't need everything on tidy paper from the start, and offices keep recipe books for how they do things.
• Part 2 needs a simple mapping first. The sheet becomes a file: on disk, a Google Doc, a Markdown file. Tasks might be a checklist in a file.
• Keep each system's analogies together: one column per system. Left column the office concepts, then a column for each kind of system:
  • plain files on disk (the original);
  • the classic Google Drive / Microsoft Office setup, which people know best: start here;
  • a task manager of some kind;
  • our approach for the AI age: Markdown files, git repos, Beads for tasks. The bigger office (rooms, central office) depends on your structure.
• Git goes in the background, near the end. Git is the underlying technology. First name the features people want: versioning, a log of what happened, traceability, syncing between machines. People already know versioning and syncing from Dropbox and Google Drive. Git is a powerful version of that, normally technical, but AI now hides the technicality. It's open, and it combines atomic commits, good versioning, conflict resolution and managing a whole file tree rather than single files. That deserves its own short section or appendix: "Why git?". Mostly we're just using files; git matters for how we sync, which Google Docs otherwise solves.

v3.2 plan: Part 2 rebuilt around one mapping (15 Oct)

Thinking through Rufus's amendments before doing them.

• One mapping table is the heart of Part 2. Rows are the office concepts. Columns are three setups, in this order: Google Drive (or Microsoft 365), the most familiar; plain files on your computer, the bare version underneath; and the AI-age setup, which is plain files plus git plus Beads. Going left to right, each column builds on the one before.
• Task managers become rows, not a column. Rufus listed "a task manager" as a system. But every setup needs one: a to-do file, Asana or Trello, Beads. So post-it and board are rows, and each column names its own tracker. That keeps the "keep analogies together" idea and avoids a column that only fills two rows.
• Rooms are left out of the table. How rooms map depends on your structure (a shared drive per team, a repo per area). One sentence of prose covers it.
• Git goes to the back. The old steps 13 (what digital adds) and 14 (git repos) merge into an extra, "Why git?", which branches off the spine like 10 and 11. It covers what people want from any cabinet (versions, a log of who did what, syncing between machines and people), says Dropbox and Drive already give some of this, and explains that git does it more thoroughly: the whole folder rather than one file at a time, changes saved together, merging, and an open format. It used to be technical, but the AI now runs it. The clone/pull/push picture moves there.
• Old steps 15 (task trackers) and 16 (drafting digitally) fold into the table and the AI-age step.

New Part 2:

  ⑫  same shapes, three ways   Google Drive · your computer · AI age
   │
  ⑬  the AI-age setup          plain text, one repo per area, tasks alongside
   │
  ⑭  the AI                    starts clean, reads the cabinet
   │
   ├──▷ ⑮ extra: why git?       versions, a log, syncing: all in one

Picture per step: ⑫ the table plus the same retreat folder drawn three ways; ⑬ an AI-age repo tree; ⑭ unchanged; ⑮ the sync diagram plus a history line with one bundled commit.