The Fact Sheet — where this leaves you

Let's go back over everything we did. Every key idea + every actionable concept from the whole talk, in their own two columns — one page, yours to take home. This is the closing wall the room reads through live; it mirrors presentations/scrollytelling-v3 exactly. Small model-building beats (010 · 020 · 050 · 100 · 110, and 120's key idea) are dropped here on purpose; 480 and 490 are folded into their parent beats.

Key ideas

• 030 A word's meaning is the company it keeps.
• 030 Word vectors put definitions into numbers — similarity becomes measurable.
• 040 The corpus decides the definition — one averaged vector per word.
• 060 Attention + next-word prediction = a text generator.
• 070 Scale alone made prediction shockingly capable.
• 080 Post-training turns "continue" into "answer."
• 090 A naked LLM has no facts — it's truthful only because the corpus mostly was.
• 130 Every turn replays the whole transcript into a stateless model.
• 140 A bigger window is not uniformly good context.
• 145 The window out-votes the weights — everything in it votes.
• 150 Style lives in the weights and the window.
• 160 Context is everything.
• 170 naked LLM + tool + orchestrator = every modern assistant.
• 180 RAG pulls the real source into the window at question time.
• 190 Code is constrained; the model is more capable there.
• 210 Gains now come from better data, not more of it.
• 220 Reasoning is next-word prediction over generated sub-steps.
• 360 An artifact is anything outside the chat window — durable, read fresh every turn.
• 320 CLAUDE.md enters every conversation — only always-applicable rules belong.
• 330 A skill loads only when the task matches — the karate chip.
• 340 Skill = context into this chat; agent = a fresh side chat.
• 345 Too big for one session? Stack agents — fan out, then synthesize.
• 350 One big-picture session; sub-agents do the breadth.
• 370 Everything around your model is your harness — it can beat a model upgrade.
• 380 Communities have built really good harnesses — superpowers among them.
• 390 Only tool calls can harm; two classifiers gate each one.
• 400 Read-only agents can't do harm — the tool isn't even there.
• 410 A hook is a rule the harness always enforces.
• 470 A Claude Artifact is the response, beautifully formatted — and shareable.
• 430 Too-big diffs get rubber-stamped — right-size everything.
• 440 A worktree = a branch in its own folder — true parallelism.
• 450 How you search determines what you get.
• 460 Agents don't do math — math becomes code.
• 500 With the stack solved, misalignment is what's left.
• 310 More of yourself in the context = better-aligned output.
• 510 Lots of good context is already written.
• 520 The vision is the stakeholder-alignment test.
• 530 Document what no agent could know.
• 540 Vision + docs = knows the project; issues = knows its job.
• 550 The layers are the failure-routing table.

Actionable concepts

• 120 Estimate tokens as characters ÷ ~4.
• 090 Distrust unsourced claims; drop "hallucination."
• 130 Unstick by pruning or resetting the history.
• 140 Know when to end the conversation.
• 145 Keep tool-bearing sessions away from untrusted text.
• 150 Paste 3+ samples of the target voice.
• 160 Paste the paper; ask about that.
• 170 Route work to tools.
• 180 Route factual questions through retrieval.
• 190 Sometimes you want the answer from code, not the LLM.
• 210 Judge new models by data and technique, not size.
• 220 Spend thinking only on complex tasks.
• 360 Pull to-dos, debug logs, drafts out of the chat and onto disk.
• 320 Direct rules: hard rules · guidance · procedures · context loading.
• 330 Codify any repeated process as a skill.
• 340 Review from a clean window: requirements + git diff.
• 345 Chain agents over consumable chunks — parallel where independent.
• 350 Consider spawning sub-agents from an orchestration session.
• 370 Inventory your harness; build the missing pieces.
• 380 Find a harness that fits how you work; install it, use it.
• 390 Back up everything, prompt cleanly, run auto mode.
• 400 Scope tools to the job; fence unattended runs.
• 410 Block absolute rules; trigger follow-on agents.
• 470 End big sessions with "make me an artifact."
• 430 Issue → branch → small PR → review → merge; artifact or explainer on the diff.
• 440 Let the harness manage worktrees; override when needed.
• 450 Write a research agent: your sources, your method, skills that reach them.
• 460 Convert your math to code.
• 500 Give the model enough information.
• 310 Dictate raw; let the model organize — and act.
• 510 Gather your documents; LLMs extract; PDF → markdown once.
• 520 Write it once, near-perfect; read it, own it.
• 530 Business knowledge · interactions · rationale — equations verified.
• 540 Word-vomit the task; the skill right-sizes it.
• 550 Every failure becomes context for the next session.

It all lives in one place. The guide, the workshop, and these sheets: llms.codebycarson.com/working-with-llms

The Links Sheet — every resource the talk points at

Every slide with a linkable resource carries a small link at its bottom — like the little "how to make a skill" link under the Skills slide that takes you to Claude's docs. This sheet collects all of them in one place, grouped by beat in the order they come up, so you can go back and dig into anything after the talk. One line each; all primary sources.

Act I — How LLMs actually work

030 · Embeddings (word2vec & GloVe) - word2vec (Mikolov et al., 2013) — predict-the-neighbors embeddings: https://arxiv.org/abs/1301.3781 - GloVe (Pennington, Socher & Manning, 2014) — count-then-factorize embeddings: https://nlp.stanford.edu/pubs/glove.pdf

060 · Transformers → next-word prediction - "Attention Is All You Need" (Vaswani et al., 2017) — the transformer: https://arxiv.org/abs/1706.03762 - The Illustrated Transformer (Jay Alammar) — the visual deeper-dive on transformers/attention referenced on the 060 slide: https://jalammar.github.io/illustrated-transformer/ - ELMo (Peters et al., 2018) — contextual embeddings, done first with an LSTM: https://arxiv.org/abs/1802.05365 - BERT (Devlin et al., 2018) — the transformer that made contextual embeddings dominant: https://arxiv.org/abs/1810.04805

080 · Post-training into a chatbot - InstructGPT (Ouyang et al., 2022) — SFT + reward model + RLHF, the ChatGPT recipe: https://arxiv.org/abs/2203.02155

Act II — Working with basic LLMs

120 · Tokens - OpenAI tokenizer — see how text splits into tokens (~4 chars each): https://platform.openai.com/tokenizer

140 · Context window & context rot - "Context Rot" (Chroma Research, 2025) — every model degrades as input grows: https://www.trychroma.com/research/context-rot - "Lost in the Middle" (Liu et al., 2023) — facts buried mid-window are recalled worst: https://arxiv.org/abs/2307.03172

150 · Style control & few-shot - "Language Models are Few-Shot Learners" (Brown et al., GPT-3, 2020) — few-shot / in-context learning: https://arxiv.org/abs/2005.14165

210 · The scaling era ends - Ilya Sutskever, NeurIPS 2024 — the full talk ("peak data," data as "the fossil fuel of AI"): https://www.youtube.com/watch?v=1yvBqasHLZs - Model collapse (Shumailov et al., Nature 2024) — training on AI-generated data degrades models: https://www.nature.com/articles/s41586-024-07566-y

220 · Chain of thought - "Chain-of-Thought Prompting" (Wei et al., 2022) — reasoning tokens before the answer: https://arxiv.org/abs/2201.11903

Act III — Modern agentic work

320 · CLAUDE.md - Claude Code — Memory / CLAUDE.md: the standing-instructions files and their up-the-tree hierarchy: https://code.claude.com/docs/en/memory.md

330 · Skills — ("how to make a skill") - Claude Code — Agent Skills: where skills live, SKILL.md frontmatter, lazy loading: https://code.claude.com/docs/en/skills.md

340 · Sub-agents — ("how to make an agent") - Claude Code — Subagents: defining custom agents and how delegation / fresh-context handoff works: https://code.claude.com/docs/en/sub-agents.md

380 · Superpowers - Superpowers plugin (obra) — the brainstorm → plan → execute → review harness: https://github.com/obra/superpowers

390 · Auto mode & safety - Anthropic — "How we built Claude Code auto mode" (the two-stage safety classifier): https://www.anthropic.com/engineering/claude-code-auto-mode

410 · Hooks — ("how to make a hook") - Claude Code — Hooks reference: every event, settings.json format, exit-code / JSON blocking: https://code.claude.com/docs/en/hooks.md - Claude Code — Hooks guide (worked examples, incl. blocking protected files): https://code.claude.com/docs/en/hooks-guide.md

430 · GitHub for teams - GitHub — About Projects (boards/tables/fields, works on personal accounts): https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects - GitHub — Sub-issues (native parent/child breakdown with rollup): https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/adding-sub-issues - GitHub — About milestones (dated buckets of issues toward a goal): https://docs.github.com/en/issues/using-labels-and-milestones-to-track-work/about-milestones

440 · Git worktrees - Git — worktrees (checking out multiple branches into parallel folders): https://git-scm.com/docs/git-worktree

460 · Math with LLMs - Lean + mathlib community — the proof assistant behind the AI-formalization results: https://leanprover-community.github.io/ - DeepMind — AlphaProof (IMO 2024 silver, proved in Lean): https://deepmind.google/blog/ai-solves-imo-problems-at-silver-medal-level/ - Practical "math → code" at the workbench: SymPy https://sympy.org · NumPy https://numpy.org · Julia/SciML https://sciml.ai

Everything in one place: the guide, the workshop, and both sheets live at llms.codebycarson.com — full how-to at /working-with-llms.

• Artifact formatting showcase (the live demo for beat 470): https://llms.codebycarson.com/artifact-example/