# Brief: the deck for Ray, Daniel and Ivan

You are making the slide deck I will present tomorrow (Tue 17 Nov 2026) to Ray, Daniel and Ivan. This brief is the approved plan, so build it. Ask me only the two questions listed under "Ask me first".

## Who it is for, and what they should leave with

Ray, Daniel and Ivan build with AI every day and know the field well. Don't explain what an agent, an MCP server or a hook is. They want mechanisms, real numbers, failures and things they can copy into their own work next week. I present it live: about 20 minutes of talk, then discussion. Every slide has to earn its place with that audience.

**The one idea:** *Don't trust the agent: gate it, measure it, prove it.* The month's work is one loop with six stations, and every project sits on one of them. Each miss becomes a hook, and the loop starts again.

## Sources: read these before you write anything

1. **The whiteboard** (made 16 Nov from the repos, logs and live servers): https://claude.ai/artifact/XmyJ5hbPiE8h9Qk53D1U2q. Read it with the Artifact tool (`action: "read"`). It holds the loop, each station's number and lesson, the system map, eight lessons and the month in numbers. It is the content source, but it is hard to read as a presentation, which is why this deck exists.
2. **The skills page** (shareable, with downloads): https://claude.ai/artifact/7xEgpiBTY5TqrfStdHfSQD. It covers the reverse-engineering method, the Claude Motion and Whiteboard skills, the `next` mod, Jev-first and the hooks. The deck's last slide links to it.
3. **The files behind each number** are listed under "Re-read every number" below. Open the file before you quote it.

## Build it with the Slides type

- First Artifact call: `action: "quickstart"`, `intent: "slides"`. Start from the Slides type it names and follow that type's instructions exactly (store, assets, layouts). Read the design systems it lists.
- **Ask me first**, in one `AskUserQuestion` call with two questions:
  1. Which design system to use (your recommendation first).
  2. Whether to name Feisst on screen or call it "a six-company construction group in New Zealand" (recommend the second).

  Everything else is decided here.
- 16:9, about 14 main slides plus 3 to 5 backup slides after a "Backup" divider.

## The slide plan

Titles are claims, not topics. Each slide holds one idea, at most about 25 words of body text, one strong number or one diagram, and a small source line naming where the number was read (for example "~/.claude/next-move/eval · 16 Nov"). Write 2 to 4 sentences of speaker notes per slide in my voice: plain, direct, first person, no hype.

1. **Title.** "A month of building with AI". Subtitle: the one idea. My name and the date.
2. **The loop.** A diagram of six stations in a cycle: Decide the next move → Brief it exactly → Build in lanes → Gate the shortcuts → Prove it live → Make it a hook → back to the start ("each miss becomes a hook"). This slide frames the whole talk, so give it room.
3. **Station 1: the `next` mod.** Claim: "Most prompt edits are noise until you measure them." It is a Claude Code mod that drafts my next message above the prompt: two moves labelled by tactic (Push, Root cause, Close the loop, Unblock, Answer first) and a meter for whether the ask has a check that proves it. Numbers: 129 of 187 suggestions sent as written or edited. On the 42 moments where I typed my own request, the live prompt's reruns scored 9 to 12 and every variant scored 8 to 11. A change ships only through `gate.sh`: tests on the Mac mini, then a replay scored by Jev against what I really typed next, which must reach the noise floor. Side point: the suggester sees only my messages and the agent's last reply, never tool output ("The Complexity Trap", NeurIPS 2025 workshop). Visual: a real screenshot of the band.
4. **Station 2: brief it exactly.** Claim: "If you can't write the steps, the problem isn't solved yet." One sun in the sky: the top seat (strongest model) thinks, Sonnet agents execute. A hook refuses any launch whose brief lacks GOAL, FILES, STEPS, PROOF, RETURN, PROGRESS and DO NOT, or that says "investigate" or "figure out". A stop hook won't let the coordinator end a turn on a failure until it has written the cause with file and line. Visual: the hook's real refusal text, which it printed when the whiteboard session tried to launch research agents on 16 Nov ("REFUSED: Agent would launch an agent without a full brief" plus the seven parts).
5. **Station 3: build in lanes.** Claim: "77% of what my lanes cost was re-reading their own context." 11 Nov, 32 lanes: 4,839 model calls re-read 1,517 million tokens, 318k a call on average and 760k in the worst lane. Polling for gates was 22% of cost (906 calls, 187 timers). The fix is a hook: no polling inside a lane, and no resuming a spent one. Limits went from 80 calls/200k to 300 calls/500k on 12 Nov, once lanes needed follow-ups.
6. **How the lanes run (ACP).** Every lane is a real Claude Code, Codex or Gemini CLI, hosted over the Agent Client Protocol as a durable session per folder, streaming every tool call, diff and permission ask, steerable and cancellable. Lesson: a launch is answered when the agent accepts it, not when its turn ends. When `start` blocked for 5 minutes, callers relaunched healthy 28-minute turns as failures. Scale: Snappy read about 3,000 agent sessions across the two Macs on 16 Nov (1,618 on the Mac mini, 1,465 on the MacBook).
7. **System map.** A diagram: MacBook (me and the top seat; no builds there, a hook sends them away) → Mac mini (the workhorse: lanes, a 60-second sweep alarming on disk, stuck locks, hung tests and drifted lanes) → Hetzner hz1–hz4 (every PR gate, the Mergify queue with up to 4 drafts checked at once, the Builder's agent) → Cloudflare + Xano (the doors: Feisst's MCP and app, the Builder, Snappy's MCP; Xano holds data and control).
8. **Station 4: gate the shortcuts.** Claim: "Write each gate rule against a shortcut you actually saw." `snappy-rust` started 10 Nov: 308 crates, 866 PRs opened and 221 merged in its first 6 days. Show the rules as a table, rule ↔ incident: crate cap 6,000 lines and module cap 800 (a 400-line file cap was dodged with 77 `_part` files, and one old crate reached 128,536 lines); a removed-test stage; a startup stage (PR #307 passed every test and panicked at boot); typed answers only, no loose JSON. On 26 Oct eight lanes wrote TypeScript beside the Rust migration, so a pre-commit gate now refuses any `.ts`, and each offending branch owed two TS lines deleted per line added.
9. **Why Rust (backup or a half-slide).** Spike numbers from 24 Oct: MCP `tools/list` p50 4.1 ms vs 38.4 ms in TS; resident memory about 19–21 MiB vs 0.7–1.2 GiB for the Node runner; `/health` p50 0.07 ms vs 13.9 ms.
10. **Station 5: prove it live.** Claim: "Done is a fresh read of the real thing, never the agent's report." The Feisst MCP is a Cloudflare Worker that lets the group's staff ask Claude or ChatGPT about simPRO, Jobpac, Navman and BambooHR, scoped per person (OAuth, access resolved on every request), with cards drawn in the chat. 118 tools on the live list on 16 Nov, up from 79 on 18 Oct. Each night it asks the live server, as every person on the register plus one stranger, what they can see. A refusal always names the next move. The text answer and the card carry the same figures from the same object.
11. **The Builder.** A diagram of its state machine: needs_detail → requested → brief_written → building → proving → waiting_on_owner → going_live → live (withdrawn from anywhere; the owner may send a build back). Staff ask for a tool in chat, agents build and gate it on Hetzner, I approve, and only a read of the app's own release moves it to Live. Honesty beat: switching on the live probe on 15–16 Nov exposed two bugs in the probe itself (a missing `Mcp-Method` header). The dogfood run on 15 Nov found that the review card offered no sample of what the tool answers, so I would have been approving a description.
12. **Station 6: make it a hook.** Claim: "A rule in a prompt fades; a hook holds." 31 hooks carry my rules into every session. Show four as rule ↔ incident: no builds on the MacBook (load 110 on 8 cores, 13 Nov); one live process per session (11 Oct: a resumed copy of a coordinator ran beside the original for 10 hours); every stop runs the strictest linters on changed files (9 Nov); old models can't be used to judge (10 Oct). Judgements go to Jev, a typed model that returns a yes/no probability, a choice or a score with a confidence: 263 ms mean over 120 asks, about $0.00003 a call. Be honest: the Jev review on every edit was tried and taken out of the global hooks on 13 Nov.
13. **Reverse engineering, with permission.** Claim: "Build to the product's real instructions, not to prose about them." It is `snappy-reverse` in seven steps: hunt publicly, open the product in my own Chrome, ask its own agent for its files, verify sha256, vendor with provenance, break down real outputs, then compare and package. Results: the Claude Motion type (16 files, 14 Oct) became a skill that makes films from my phone (a 15-second film in 72 s); the Whiteboard type (16 Nov) is next. My own accounts only; the vendor's files are never redistributed.
14. **Rows, not code.** In my media app on Xano, vibes, video models, provider routes and recipes are database tables, not code. The 157 vibe rows are served by one endpoint (cached 60 s), so an edit reaches the app in about a minute with no deploy, and a new video model on any provider is a row, not a release. Xano also rents and shuts down its own GPU machines, with a 60-second dead-man switch and a $5 daily cap. Architecture only: say nothing about what the app makes.
15. **Lessons that became rules.** Six to eight short dated lines from the whiteboard's "Lessons" section, for example: 6 Nov, a test passes only when it proves everything that was asked; success is the default lie (an empty grep reads as zero); 11 Nov, the server decides and the app draws; a value you don't hold is "unavailable" with one sentence saying why; 12 Nov, read the provider's docs and run its defaults before any paid run.
16. **Take this home.** Three things to try next week: Jev-first (three commands), the brief gate, and the replay eval for any prompt you keep tuning. Link to the skills page. End on the one idea.

**Backup slides:** the month in numbers (table below), the two-Claude whiteboard protocol, the Motion relay architecture, the next-mod prompt's five tactics with their exact one-line definitions (`~/.claude/mods/next-move/hooks/prompt.ts`, `MEANS`).

## Visuals: real captures, never mock-ups

Use Snappy's tools (load with ToolSearch `snappy-mcp`, max_results 80) for every screenshot:

- **Web pages in my signed-in Chrome:** `browser_act` `open_tab`, then `browser_look` `show: "screenshot"`. Candidates: the snappy-rust pull requests and Mergify queue on GitHub, the whiteboard, the skills page, the Builder's request card.
- **Apps on my Mac:** `mac_look` (the `next` band above a Claude Code prompt).
- Crop each capture to the element, render at 2x and upload it through the Slides type's asset road. A screenshot that would show a client's money figure, a person's name other than mine, a token or a private host name is cropped or left out. If you can't tell, leave it out.
- If a page shows a sign-in wall, skip that capture and use another source. Never ask me to sign in to anything.
- Draw diagrams (the loop, the system map, the Builder states, the two-Claude board) in the deck itself, as the Slides type draws them.

## Re-read every number

The numbers above were read on 16 Nov 2026, and some move daily. Before a number goes on a slide, read it again from its source. If it has changed, use the new one and say "as of 17 Nov". If you can't re-read it, keep the 16 Nov value and say "as of 16 Nov".

| Number | How to read it fresh |
|---|---|
| snappy-rust PRs merged / opened | `gh api "search/issues?q=repo:roboulos/snappy-rust+is:pr+is:merged&per_page=1" -q .total_count` and the same without `+is:merged` (221 / 866) |
| snappy-rust crates | `gh api repos/roboulos/snappy-rust/contents/crates -q length` (308) |
| gate rules | `gh api repos/roboulos/snappy-rust/contents/crates/gate/README.md -H "Accept: application/vnd.github.raw"` |
| PRs merged since 16 Oct | the same search with `+merged:>=2026-10-16` for snappy-runner (817), snappy-swift (120), snappy-kernel (90) |
| Feisst live tools | count the `feisst_*` tools the Feisst connector lists in your session (118); 79 is from `~/Projects/feisst/README.md` |
| `next` mod | `~/.claude/next-move/eval/corpus.json` outcomes and `runs/*/rescored.json` (`hit` of `asking`); `runs/noise.json`; `gate.sh` |
| lane cost | the header comment of `~/Projects/snappy/kernel-installed/hooks/lane-budget.mjs` |
| brief gate | the header of `~/.claude/hooks/agent-brief-gate.mjs` |
| hooks | `~/.claude/settings.json` hooks plus `~/.claude/hooks/hook-dispatch.pre.json` and `.post.json` (31 distinct scripts, excluding the status-line and terminal ones) |
| Snappy sessions | `mcp__snappy-mcp__machine_agents` with `scope: "all"`: `page.read` per Mac |
| Rust vs TS | `~/Projects/snappy/RUST-MIGRATION-BRIEF.md` and the top of `~/Projects/snappy/HANDOFF.md` |
| Builder | `git -C ~/Projects/snappy/snappy-builder-mcp show origin/main:src/domain/lifecycle.ts`, `…:docs/dogfood-20261115.md` |
| Jev | `~/.claude/skills/snappy-jev-first/SKILL.md` (263 ms over 120 asks, pricing) |
| Motion | `~/.claude/skills/snappy-claude-motion/SKILL.md` and `PROVENANCE.txt` |

## Leave out

- What my media app makes. It appears only as the "rows, not code" architecture.
- Client money figures, staff names and anything else private to Feisst.
- Credentials, tokens, private host names and account emails.
- Anthropic's artifact-type files: describe the method, never paste their text.

## How to work

- Don't launch research agents. A hook refuses any subagent without a full brief (GOAL, FILES, STEPS, PROOF, RETURN, PROGRESS, DO NOT, GATE READ, model Sonnet), and this job is mostly reading what is already gathered here. Do it yourself.
- Builds, tests and disk-wide searches are refused on the MacBook. `gh api`, reading files and the Snappy tools are fine.
- Order: read the two artifacts, ask the two questions, re-read the numbers, capture the screenshots, then build the deck in one pass with notes. Look at every slide once through `browser_look` in my Chrome, fix what overflows or reads badly in one pass, and hand over.
- **Hand over with:** the deck link; a short table of every number on the slides with its source and whether it was re-read today; and what you left out and why. The deck stays private until I share it. Don't send it to anyone.
