v10

Section 1 — Foundations + Claude Code CLI

Summary — what this page covers The conceptual + setup foundation. Attendees build a working mental model of how Claude Code behaves (tokens, context window, turns, grounding), install and authenticate, learn the core CLI/REPL, write their first CLAUDE.md, understand the permission model, and explore an unfamiliar .NET codebase. Pair this page with Lab 1.

9:00 – 10:30 AM · 90 min — 40 min lecture/demo + 50 min lab

Learning objectives

  • Articulate what separates Claude Code from autocomplete tools and copilots

  • Explain how LLMs work — tokens, context windows, turns, temperature, grounding — and use that model to make practical decisions (when to read before writing, how to budget context, when to start a fresh session)

  • Install on Windows (WSL2), macOS, Linux; authenticate via API key or subscription

  • Operate Claude Code from the terminal (REPL + one-shot); know that the same agent runs in VS Code and JetBrains (set up in Section 3)

  • Author a meaningful CLAUDE.md

  • Use the permission model safely

  • Explore a real, unfamiliar .NET project

Content

Block 1A — The landscape (≈25 min)

Why this moment is different: tools that assist → agents that execute. Autocomplete and copilots suggest the next line while you type; you stay the driver, accepting or rejecting tokens. Claude Code is an agent: you hand it a goal, and it plans, reads files, runs commands, edits code, checks the result, and corrects itself — across many steps — before handing control back. The unit of work moves from "a suggested completion" to "a completed task." That shift is why the rest of the day is about steering a worker, not prompting a text box.

The developer's mental model. You don't need the math behind LLMs, but five mechanics explain almost everything Claude Code does:

  • Tokens — text is processed in tokens, roughly ¾ of a word in English. Everything you and Claude exchange is counted in tokens, and tokens cost money and space.

  • The context window — the model's working memory. Your system prompt, CLAUDE.md, every file Claude reads, the conversation so far, and every tool result all share one finite budget. It's large, but not infinite — when it fills, older content gets summarized (compacted) or pushed out.

  • Turns — a turn is your prompt plus Claude's response, and that response is usually a loop: read a file → run a command → read the output → edit → re-check, then reply. Expect an agent working, not a single answer appearing.

  • Temperature — how random the output is. For code you want consistency, so Claude Code runs at a low temperature — the same request tends to produce the same, predictable result.

  • Grounding vs. recall — an LLM predicts plausible text. Ask about code it hasn't seen and it may produce something plausible but wrong (a hallucination). Show it the real file and the output is grounded in fact. The rule of the day: if Claude can't see it, it may invent it — tell it to read before it writes.

From mechanics to decisions (this is the outcome: apply the model to real choices). Each mechanic above implies a practical habit:

  • The context window is finite → budget it. Keep CLAUDE.md lean, /clear between unrelated tasks, and push heavy, noisy work into a subagent (Section 2) so it doesn't crowd your main window.

  • Grounding beats recall → make Claude read first. Point it at the relevant files before asking it to edit; don't rely on its memory of your codebase.

  • Turns are a loop with tools → expect iteration. Let it run the build, see the error, and try again — that loop is the feature, not a detour.

  • Model tiers exist → match the model to the job. Haiku for fast, mechanical work; Sonnet/Opus for real reasoning — a lever you'll pull for subagents in Section 2 and the API in Day 2.

Three products, one brand. Don't confuse the surfaces:

  • Claude.ai — the web/desktop chat app (and Projects, Artifacts). Conversation, not your repo.
  • Anthropic API — the models exposed programmatically; what you build against in Day 2.
  • Claude Code — the agent that lives in your terminal and IDE and acts on your real codebase. That's today.

Same underlying models; very different ways to use them.

Block 1B — Installation & configuration (≈35 min)

  • Install paths. macOS/Linux use a one-line npm install; Windows runs everything inside WSL2. If you completed Before You Begin, this is already done — we'll only troubleshoot stragglers here.

  • Authentication options. Sign in with your Claude.ai subscription via browser OAuth (recommended today) or export an API key (ANTHROPIC_API_KEY, pay-as-you-go — the Day 2 path). See Before You Begin for both.

  • Operate from the terminal. Two ways to run the same agent:

    • the interactive REPL — type claude, then converse and iterate across turns;
    • one-shot mode — claude "prompt" runs a single request and exits, ideal for scripts.

    Useful from the start: /help lists commands, and claude --continue resumes your last session. Same agent, three surfaces — VS Code and JetBrains (Rider/IntelliJ) integration comes in Section 3. The Command Reference collects the rest.

  • CLAUDE.md basics (teaser). A CLAUDE.md at your repo root is loaded at session start and becomes part of the system prompt — your project's standing briefing for Claude. Bootstrap one with /init, and append a fact mid-session by starting a line with #. That's enough to get going; the deep treatment — "keep it under 200 lines; it's a map, not a junk drawer" — lives in Section 2.

  • The permission model. Claude Code asks before it does anything consequential — running a command, editing a file — with an interactive prompt you approve or deny. You can allow-list trusted actions so it stops asking about routine ones, and run headless (non-interactive) for automation. The point: you stay in control of what touches your machine.

Block 1C — First real session demo (≈20 min)

A live exploration of BookTracker — Claude reading the solution, mapping the projects, and answering "how does this app work?" grounded in the actual files. This previews exactly what you'll do hands-on next, so watch how the agent reads before it answers. (Instructor demo prompts live in _instructor/demo-plan.md.)

Demos referenced here

  • Installation Walk-Through · CLAUDE.md Creation · Live Codebase Exploration [Instructor scripts live in _instructor/demo-plan.md.]

Key takeaways

  • Claude Code is an agent, not autocomplete — you hand it a goal, it executes a multi-step loop.

  • Context is power — read before you write. Grounding in real files beats the model's memory.

  • CLAUDE.md is your project briefing — loaded every session, it tells Claude how your code works.

  • The LLM mechanics aren't trivia — they drive decisions: what to read, what to keep in context, which model to use, and when to /clear and start fresh.

  • You hold the permissions. Nothing consequential happens without your approval.

→ Continue to Lab 1.