Reference · print this
Speaker's card for the 24 slide deck, version 6. Audience: professional developers who have never used a coding agent. The deck teaches the basics of agentic development, not the skills catalogue.
| Min | Slides | Beat | Say this |
|---|---|---|---|
| 0–2 | 1–2 | Open | This is not a machine learning topic. Nobody has to train anything. Their engineering judgement is the asset, and it transfers. Say it plainly; it decides whether the next 27 minutes land. Then give them the frame they keep all session: "AI is not a super-powered developer. It's a new starter with no memory." Land the qualifier on the same slide: no memory between sessions. Every session starts empty. Say it now, because slide 15 shows a file the agent reads every time, and somebody will ask. |
| 2–6 | 3–4 | The machine | The foundation beat. Slow down here. Nobody in the room has run one of these. Slide 3 is the mechanism: a model, a set of tools, and a loop. Walk the cycle — read a file, edit it, run the tests, read the output — then point at the return edge: not finished, go again. Point at the exit arrow: done. Give the gloss in the deck's own voice: a tool is one action the agent can ask for. Slide 4 shows the same loop in a real terminal. Nothing on that slide is mocked up. Read it top to bottom: one typed prompt, the model asks for a tool, the harness runs it and hands back the result, and then the agent stops and asks before it edits. Land the footer: one prompt, five tool calls. It ran the shell on my machine, and it waited. Say as an aside: a workflow is code that decides the next step; in an agent the model decides. Say it only if somebody asks; it is not on a slide. |
| 6–10 | 5–8 | The loop closes | Four minutes, four slides. This beat answers the question slide 3 raises and does not close: how does the agent know it is finished? Slide 5 shows a test, and the code it checks, because slide 3 already said "run the tests" and nobody in this room has been told what one is. Read both files aloud: sum.js adds up a list and its loop stops one item early; sum.test.js says the answer for one, two, three, four must be ten. Land the footer: a test runs your code and checks the answer, and it ends in one word. Slide 6 runs it. Point at not ok and at actual: 6. Say the important part: nobody told the agent it was wrong. It ran the test and read the answer, and that text lands in the context window like any other tool output — which is the whole of slide 10 in the context spine, still to come. Slide 7 is the same session as slide 4, further down: the test passes, and the agent explains the off-by-one in its own words. Point back at slide 3's done arrow. A pass is what ends the loop; without one the agent stops when it merely believes it is finished. Slide 8 says why this works on an agent and not on a person: it does not get bored of running the same check. Say as an aside: a type checker is the same idea and it is cheaper than a test; slide 21 lists four of these loops, and this beat is why that slide matters. |
| 10–18 | 9–15 | Context | Eight minutes, seven slides. This is the talk. Slide 9: "An agent can only work with what's in its context window." It never read your codebase; it read what fitted. Slide 10 is the first diagram: most of the window is not what you typed, and most of it you never see — system prompt and CLAUDE.md, file contents, command outputs, conversation history, then your prompt, the smallest slice. Define a token here, because slide 12 counts them: a thousand tokens is roughly 750 words, and a full window is about a short novel. Slide 11 draws the same window with a fade and a dashed line: the smart zone fades into the dumb zone. Point at the dashed line. People debate where the boundary sits; nobody debates that it exists. A session can be deep in the dumb zone with most of the window still free. Slide 12 answers why: attention is a fixed budget, spread across everything in the window. The amber square never changes size; only the field around it grows. Ten times as much in, a tenth of the notice each. Say the line: a gradient, not a cliff. Slide 13 is the fix they can use on Monday: /clear between tasks, one task per session. Gloss it — a slash command is something you type into the agent. Land the trap at the bottom of slide 13. Paste in more documentation to fix drift and you grow the context and make the drift worse. The fix is removing context, not adding it. Say as an aside: a subagent explores in its own window and reports back a summary; keep it for a question. Slide 14 reads their own week back to them: kitchen sink, corrections, exploration. Read the three patterns and let the room recognise itself, then land the line: corrected more than twice, /clear and start over. Slide 15 answers the tagline: no memory, so where do you write it down? CLAUDE.md is where the new starter gets told. Land the trap: the file costs context too, and a bloated file makes Claude ignore your actual instructions. Keep it under 200 lines. |
| 18–26 | 16–22 | Skills | Eight minutes, seven slides. This is the deck's answer to the eight minutes you just spent on context. Slide 16: CLAUDE.md is what the agent always knows; a skill is what it knows when it needs to. Only the name and description sit in context until the task calls for it. Slide 17 is the hinge, and it is one line: "The spec exists because context windows end." Pause here. This is where the two halves of the talk meet. The session ends and everything you agreed dies with it; the tickets are disposable and the spec is not. Slide 18 is Matt's pipeline, five skills you type in order, each with his own one-line description: /grill-with-docs, /to-spec, /to-tickets, /implement, /code-review. Say /tdd is inside implement, not a sixth stage. If the room asks about the rest of the catalogue, say so: Matt has 25 skills in 6 groups, /ask-matt routes between them, and this deck shows only the main flow on purpose. Slide 19 is the payoff, and it is the slide that sells the flow: the same ticket run cold, then run with the flow. Read the two columns side by side. Cold, you type the whole brief again from memory after every clear. With the flow, you write the brief once and every later session reads it. Slide 20 is stage one, the grilling: vague requirements in, a plan out, before any code. Give them the keystroke — Shift+Tab enters plan mode, and --permission-mode plan does it at launch. Say as an aside: plan mode blocks edits, but the agent still runs commands to explore. Slide 21 is inside implement: four feedback loops, cheapest first. Ask the room which one their repo is missing. Say as an aside: Claude Code has its own hooks at PostToolUse and Stop; the slide shows a git pre-commit hook only. Slide 22 is their first skill. Read /grill-me aloud — three sentences, and that is the whole skill. Name the pair in the footer: /grill-me talks, /grill-with-docs writes it down. |
| 26–29 | 23–24 | Close | Four actions, in order of the day they happen. Monday: one real ticket, in plan mode, Shift+Tab, no code until the plan is right. Tuesday: run /grill-with-docs on the next ticket, and keep the file it writes. This week: one feedback loop the agent can fail against, a typecheck or a pre-commit hook. Every time: read the diff — you are still the engineer. Slide 24 closes on the "fleet of middling to good engineers" quote and the five stages once more, then the last line: "No memory. So write it down." |
The deck runs 29 minutes, not 25. Slides 5 to 8 added the loop-closing beat. If you are booked for 25 minutes, decide before you start: either book 30, or drop the beat as a block and keep the four minutes. Do not cut it slide by slide — slide 5 defines a test and slides 6 and 7 spend it, so half the beat teaches nothing. If you drop it, say one sentence while slide 4 is still up: the agent knew it was finished because a test told it, and slide 21 shows four checks that can tell it. Drop the beat only for a room that already writes tests; a room that does not is the room it was written for.
Then cut in this order, and cut on purpose.
First cut: the spoken asides. Drop the workflow-against-agent aside at slide 4, the subagent aside at slide 13, the plan-mode aside at slide 20, and the Claude Code hooks aside at slide 21. Each is one sentence, and each is an answer to a question nobody has asked yet.
Second cut: the /ask-matt aside at slide 18 about the 25 skill catalogue. Answer it only if the room asks.
Third cut: slide 14. The three dirty-session patterns are the most enjoyable slide in the deck and the least load-bearing. Slide 13 already carries the fix.
Last cut: slide 19, the payoff. Cut it only when nothing else is left. It is the one slide that shows the flow getting smoother instead of saying so. If you must drop it, summarise it in one sentence while slide 18 is still on the screen: you write the brief once, and every later session reads it.
Stop cutting there. The context spine, slides 9 to 15, is the focus of the talk and is never cut as a block — inside it, slide 10 shows what is in the window and defines a token, slide 11 gives the smart zone and the dumb zone, slide 12 gives the mechanism, and slide 13 carries the only fix and the trap. Never cut slide 3 or slide 4: the room has never used an agent, and those two slides are the whole machine. Never cut slide 17, "The spec exists because context windows end" — it is the hinge where the two halves of the talk meet. Never cut slide 20 or slide 21: together they are the two habits, framed as stages of the flow. Never cut slide 22, /grill-me — it is the only skill the room sees in full, and it is what Tuesday's line asks them to copy.
Do not add a demo to fill the time. Spend it on the room instead. First: go back to slide 14 and ask which of the three patterns they recognise. That answer is worth more than any extra slide. Second: go back to slide 10 and ask what they think the biggest slice in their own window is. Most rooms guess their own prompt, and it is the smallest. Third: take questions from the table below, and route each one to the slide that answers it.
This is enrichment, not a buffer. Slide 4 already shows the room a real session, a real tool call and a real permission prompt, so the foundation of the talk does not depend on anything running live. A live run is more convincing, and it can fail in front of the room. Decide before you start, and keep slide 4 either way.
If you run it: enter plan mode against one real ticket, and let the room watch the agent ask clarifying questions. Second choice: open a real repository and show what a blocked pre-commit hook sends back to the agent. Both need a prepared repository, a warm session and a rehearsal. Never run either one for the first time in front of the room.
| Question | Answer |
|---|---|
| "What does an agent session actually look like?" | Slide 4. Go back to it and walk the lines again. One typed prompt, then the model asks for a tool, the harness runs it, and the result comes back into the same session. Five tool calls from one prompt. It edits nothing until it asks. |
| "What is a test?" | Slide 5, and both files are on the slide. A test is code that runs your code and checks the answer. sum.test.js calls sum([1, 2, 3, 4]) and states the answer must be 10. Run it and you get one word back: ok, or not ok. That word is the whole point — it is a signal the agent can read without you. |
| "How does the agent know when it is finished?" | Slides 6 and 7. It runs a check and reads the result. On slide 6 the check fails, so the loop goes again; on slide 7 it passes, and that is the done arrow from slide 3. Without a check it stops when it believes it is finished, which is a different thing and is the failure Matt names: "Poor feedback loops. The AI doesn't receive feedback fast enough, so it doesn't know if what it changed actually did what it intended." (how-to-make-codebases-ai-agents-love) |
| "We have no tests. Can we still use an agent?" | Yes, and slide 21 is the answer: a test is only one kind of feedback loop, and it is not the cheapest. A type checker is "essentially free feedback for your AI", a linter and a formatter cost nothing to run, and a pre-commit hook blocks the commit and hands the agent the error. Start with whichever one your repo can run today. The point is not tests; it is an automatic answer the agent can get without asking you. |
| "Why does repeating a check work on an agent when it annoys people?" | Slide 8. "AI agents don't get frustrated by repetition. When code fails type checking or tests, the agent simply tries again." (essential-ai-coding-feedback-loops) A reminder in a prompt is read once and competes for attention with everything else in the window. A check runs every time and cannot be forgotten. |
| "What is a token?" | Slide 10. A token is a chunk of text, and it is the unit the context window is measured in. "a thousand tokens is roughly 750 words" (ai-coding-dictionary/token). So a 100,000 token window is around 75,000 words — a short novel, held in one session. |
| "Why does quality fall?" | Slide 12. Attention is a fixed budget, and every token in the window draws on it. "Like humans, who have limited working memory capacity, LLMs have an 'attention budget' that they draw on when parsing large volumes of context." (anthropic.com/engineering/effective-context-engineering-for-ai-agents) The thing you care about does not get smaller. The field around it gets bigger, so each thing gets less notice. A gradient, not a cliff. |
| "How do I enter plan mode?" | Slide 20. Press Shift+Tab in the session. "Switch permission modes with Shift+Tab in the CLI, the mode indicator in VS Code, or the mode selector in Desktop." At launch, use claude --permission-mode plan. Plan mode blocks edits, not commands: "Claude reads files, runs shell commands to explore, and writes a plan, but does not edit your source." (code.claude.com/docs/en/permission-modes) |
"What is the difference between /grill-me and /grill-with-docs?" | Slide 22. Both interview you. Only one writes the result down. /grill-me is "Align on an idea before committing to it." /grill-with-docs is "Get interviewed about a plan, and record the decisions." (aihero.dev/skills) Matt puts it plainly: "It is stateful. Every other grilling skill leaves the session in your head; this one leaves files on disk." Use /grill-me to think. Use /grill-with-docs when the answer must survive the session, which is most of the time. |
| "Does this replace me?" | Go back to slide 2. The agent has no memory and no opinion about what is worth building. It also cannot tell you the plan is wrong. |
| "What is the difference between an agent and a workflow?" | Not on a slide; this is the spoken aside at slide 4. In a workflow the code decides when to stop and what to call next. In an agent the model decides. "It calls an LLM and gives it a bunch of tools, different options of things that it can do next." (what-is-an-agent) The agent trades predictability for flexibility, and that trade is why constraints matter. |
| "It keeps forgetting what I told it." | Slides 9, 11 and 15. Each session starts with a fresh context window, so it never knew. In a long session it also drifts into the dumb zone. Clear the session and start again. Put the fact in CLAUDE.md, or in the spec, so the new starter reads it next time. |
| "Where exactly does the dumb zone start?" | Nobody agrees, and the deck shows no number on purpose. Matt gives three different figures. The Ralph post says the smart zone is the "First 40% of context" (why-the-anthropic-ralph-plugin-sucks). The dictionary says the dumb zone starts around 125K-150K tokens (ai-coding-dictionary/smart-zone). The grilling post says around 120k tokens (things-people-get-wrong-with-grill-me-and-grill-with-docs). The same Ralph post says it best: "Most people debate exactly where this boundary is, but everyone agrees the boundary exists." That is why the line on slide 11 is dashed and labelled "debated". |
| "Models have huge context windows now. Does this still apply?" | Yes, and the size is not the point. Slide 12. Quality falls as the window fills, on every model. Anthropic calls it "a performance gradient rather than a hard cliff". Matt puts it plainly: "even if that model supports a big context window, you'll definitely still get better results from using fewer tokens in the context." A bigger window buys you room, not accuracy. |
| "Why not just paste in more documentation?" | That is the trap on slide 13, and it is the most common beginner mistake. If the agent drifts from what you told it, the knowledge is usually already there and is losing the competition for attention. More documentation grows the context and makes the drift worse. Remove context instead: clear, or start the task again in a fresh session. |
| "Is compaction not the answer?" | It helps, but it is not free. Compaction is lossy, and autocompact fires at a moment you did not choose. The classic symptom is an agent that carries on confidently and has quietly dropped a constraint you set an hour ago. Prefer one task per session, and clear on purpose. "Compaction is lossy, and autocompact is lossy at a moment you didn't choose." (ai-coding-dictionary/autocompact) |
| "How long should CLAUDE.md be?" | Short. "target under 200 lines per CLAUDE.md file." "Longer files consume more context and reduce adherence." (code.claude.com/docs/en/memory) A bloated file is the trap on slide 15: it costs context, and Claude starts ignoring it. |
| "If subagents run in a separate window, do they still cost me anything?" | Not on a slide; this is the spoken aside at slide 13. "Subagents run in separate context windows and report back summaries." (code.claude.com/docs/en/best-practices) The exploration cost stays in the subagent's window. Only the summary lands in yours. |
| "Do I have to approve every action?" | Slide 4 shows the permission prompt. You choose how much to grant. "Claude Code only has the permissions you grant it. You're responsible for reviewing proposed code and commands for safety before approval." (code.claude.com/docs/en/security) The permission model itself is a session 2 topic. |
| "Can I just /rewind instead of committing?" | No. "Checkpointing with /compact and /rewind is not a replacement for git. Always commit work before switching branches or running major commands." (code.claude.com/docs/en/best-practices) |
| "We are not a TypeScript shop." | The four loops on slide 21 are examples, not the point. Any automatic pass-or-fail signal works: a compiler, a linter, a test command, a hook. |
| "How is a Claude Code hook different from a git pre-commit hook?" | Slide 21 shows the git hook only. All four loops on that slide are things the code base can fail against, and the hook named there is a git pre-commit hook: it fires on a git action, so it can only block the commit. A Claude Code hook is a different thing that shares the name. It fires on the agent's own lifecycle, at PostToolUse or Stop — the pair named in the spoken aside, and not on any slide. Only the second one gives the error back to the agent while it is still working, so the agent fixes the problem itself. |
| "Is a skill just a slash command with new branding?" | Close enough to say yes. "Custom commands have been merged into skills." (code.claude.com/docs/en/skills) If you already write slash commands, you already write skills. |
| "How long can a skill be?" | "Keep SKILL.md under 500 lines. Move detailed reference material to separate files." (code.claude.com/docs/en/skills) Slide 22's /grill-me is three sentences — most of that budget goes unused. |
| "Why not just put this in CLAUDE.md instead?" | "Unlike CLAUDE.md content, a skill's body loads only when it's used, so long reference material costs almost nothing until you need it." (code.claude.com/docs/en/skills) CLAUDE.md loads every session, in full. A skill's body loads only on demand — the fact slide 16 rests on. |
| "Can I just ask the agent to write the skill for me?" | Careful. "Ask an agent to write instructions for another agent and it spends most of its words explaining what the model already knows. Every one of those lines is a no-op." (skills-writing-for-agents) Write it yourself, short, the way slide 22 shows. |
| "Why not skip straight from the grilling to tickets?" | Because the spec is what survives. "the tickets are disposable and the spec isn't" (skills-to-spec) A session can die mid-task. The written spec is what the next one reads. That is slide 17. |
| "Is a skill the same thing as a subagent?" | No. "Each subagent starts with a fresh, isolated context window." (code.claude.com/docs/en/sub-agents) A skill's instructions load straight into your main window. A subagent's work happens in a separate one, and only a summary comes back. |
| "How many skills are there?" | 25 skills in 6 groups on aihero.dev/skills. Slide 18 shows five of them, the main flow, on purpose. /ask-matt — "Find out which skill to use for the situation you are in." — routes you to the rest. The full catalogue is a session 2 topic. |
| "What does it cost?" | A fair question, and there is no slide for it. It needs its own session. Say what is true: the cost tracks the tokens in the window, so every habit in this talk — one task per session, /clear, a spec instead of a re-typed brief — lowers it as well as improving the output. |
| "Where do I start on Monday?" | One real ticket, plan mode, no code until the plan is right. Slide 23. |
Accuracy note. Every quotation in this deck was fetched
from the Markdown twin of its page and checked character by character: the
opening and the context spine on 2026-08-27, record in RESEARCH.md
and CONTENT-BRIEF.md; the two context-quality slides on
2026-08-28, record in RESEARCH-CONTEXT-QUALITY.md; the skills
act on 2026-08-28, record in RESEARCH-SKILLS.md. If someone
challenges a quote, the source is on the slide.
This runsheet describes deck v5, rebuilt on 2026-08-29.
The audience assumption is now stricter: developers who have never
used a coding agent. Earlier passes assumed almost none. That change
produced most of v5. See
learning-records/0010-never-used-an-agent.md.
Slide 4 is new and it is the highest-value slide in the deck.
It is a real captured session: a real prompt, a real tool call, a real tool
result and a real permission prompt. Nothing on it is a mock-up. It replaced
a slide called "Who stops it", which taught the difference between a workflow
and an agent. That distinction is knowledge for people who build
agents; this room will use one. It is now a spoken aside only. See
learning-records/0011-terminal-over-taxonomy.md.
Slide 12 was rebuilt. The old N² "attention pairs"
argument and its three bars are withdrawn. The bars were
156, 208 and 260 pixels for quantities of 1, 100 and 10,000 — an unlabelled
log scale — while this runsheet told the speaker to say the count grows with
the square of the tokens. The picture and the script contradicted each other.
Do not say "pairs" and do not say "N squared". Say the fixed
budget: attention is one budget spread across everything in the window, so ten
times as much in means a tenth of the notice each. See
learning-records/0012-withdraw-the-pairs-figure.md. If the room
asks for evidence beyond the Anthropic quote, name two sources. Neither is on
a slide, and neither was re-fetched for version 5, so give them as reading,
not as a quotation: Chroma tested 18 models and found "performance grows
increasingly unreliable as input length grows"
(research.trychroma.com/context-rot),
and "Lost in the Middle", Liu et al., TACL 2023, found performance highest
when the relevant text is at the start or the end
(arxiv.org/abs/2307.03172).
The live demo is no longer the buffer. Earlier versions of this runsheet put it under "if you are running short", which made the most convincing part of the session depend on spare time and a working repository. Slide 4 now carries that load. The demo is optional enrichment, in its own section above.
The "no memory" frame needs one qualifier, and slide 2 now carries
it. If someone says the agent does have memory, they are right:
Claude Code reads CLAUDE.md and writes auto memory. The frame in
this deck is about one thing only — each session starts with a fresh context
window.
Figures kept as background, not on any slide. The dumb-zone boundary numbers, above. The instruction budget: "Frontier thinking LLMs can follow ~150-200 instructions with reasonable consistency." That is Kyle from Humanlayer, quoted by Matt. It is not Matt's own measurement, so attribute it correctly or leave it out.
The "fleet of middling to good engineers" line was dropped for a time as unverifiable, cited to the wrong page. That finding was right about the page and wrong about the quote: the text is real, and lives at 5-agent-skills-i-use-every-day. It is on slide 24. Cite only that page.