Claude Code 101: teaching notes

"There are twelve ideas in this course, one per screen. They all point at one change. Up to now, Claude has given you text and you did the rest: you copied it out, used it, fixed it. Claude Code does the work itself, in your own files, on your own computer. For each idea I'll show you it working, then stop and ask where it fits in your week. You don't need to remember it all today."

"This is the plan for the session, in four parts. First, what Claude Code is and how it works. Then, getting it running on your machine. Then, the one workflow to learn: explore, plan, code, commit. And last, how to set it up for your own work. If a term comes up and you don't know where it belongs, we come back to this screen."

"In a chat, you ask a question and get text back, and then the rest is on you: you copy the answer out, use it somewhere, and paste back whatever went wrong. An agent removes that carrying. It reads your files, edits them, runs the commands, checks the result, and keeps going until the job is done. It's the same Claude you know from the browser. The difference is that it can act on your computer instead of only answering." (Pairs with framings.md: the folder is the memory: the work moves out of a chat you lose and into a place that persists.)

"Underneath, it runs a cycle. You give it an instruction. It gathers the context it needs. Then it acts: it edits files, runs commands, searches. Then it checks its own work, and if the result isn't right, it tries again. When it's done, it stops and waits for you. You can step in at any point along the way: add a file, correct something, or send it in a different direction." (Four parts make the loop run: the loop itself, a managed memory, the tools it can call, and the permissions you control. That combination is what a chat doesn't have.)

"You can run Claude Code in five places: in the terminal, inside an editor like VS Code or JetBrains, in the desktop app, and on the web. The terminal gets new features first. The desktop app is the easiest place to start, because it runs in the background while you do other things. The rule that matters is the same everywhere: you start it in a folder, and it can see that folder and everything inside it, and nothing above it." (framings.md: demystifying the terminal: it's just the bare-metal way to talk to your computer, the same cd you typed to launch a game in the nineties.)

"One key, Shift + Tab, sets how closely you watch it work. There are three settings. Approval mode asks you before every change; that's where you start, because watching it ask is how you build trust. Auto-accept lets the edits happen without asking, for when you've seen the pattern enough times. And Plan mode is read-only: it studies the files, asks its questions, and gives you a plan. Nothing changes until you approve the plan." (objections.md: permission: confirm-each-step first, switch to auto when the pattern is familiar, you always check the end.)

"If you keep one thing from today, keep this workflow. It has four steps. First, explore: it reads what's already there. Second, plan: it writes out what it intends to do, and you correct that plan. This is the cheap place to catch a mistake: changing a plan takes a minute, changing finished work takes an afternoon. Third, it does the work, back and forth with you. Fourth, you review the result and commit it. Most people skip straight to the third step, and then spend their time correcting the output." (framings.md: the 80/20 expectation, set it here, before any live run: "You'll get ninety percent of the way; you finish the last ten, and even eighty percent is an enormous cut.")

"Claude has a working memory, and it fills up. Every file it reads and every command it runs takes up space in it. Three commands manage that space. /compact summarises the conversation so far: you keep the thread of the task but free up room, so use it in the middle of a long job. /clear empties the memory completely, for when you start something unrelated. /context shows you what's taking up the space. Anything you want it to keep beyond the session goes in a file, and that file is the next slide." (framings.md: context window: the browser chat forgets the beginning once it runs long; here the memory is bounded by your disk, not a chat.)

"The Claude that did the work is not a good judge of it, for the same reason you're not a good judge of your own writing: it made the choices, so it defends them. So before the work goes out, a second Claude reads it with no memory of how it was made. It can point at problems, but it can't change anything. Then one command saves the work and posts it for review. And you can come back to that piece of work later and carry on from where you stopped." (Adapt to their world: this is the same instinct as a colleague checking your work before it goes to the client.)

"This is the most important file in the whole system. CLAUDE.md is a plain-English file that holds the rules of your work: what the project is, how you want things done, what to never do. Claude reads it at the start of every session. So instead of re-explaining your rules every time, it starts already knowing them. And because it's an ordinary file, you can share it: put it in the shared project folder and the whole team works from the same rules." (framings.md: skill file as institutional memory: "those rules lived in your senior person's head and walked out the door at six o'clock; this pulls them onto disk so a new joiner writes the same kind of work on day one." Adapt the role to the room.)

"Some jobs need a lot of digging: reading through half the files to find one thing. If your main session does all that reading, its memory fills up with material you don't need. A subagent fixes that. It's a helper that does the digging in its own separate memory and sends back only the answer, so your main session stays focused on the task. You create one just by asking; Claude writes the setup for you." (Plain framing: it's like asking a researcher 'go find me this' and getting a one-paragraph answer, not their twenty open tabs.)

"A skill is a set of instructions for one repeatable task: the steps, the rules, the format, written down once. When that task comes up, Claude loads the instructions and does the job your way. The rest of the time the skill costs almost nothing, because Claude only holds its name and a one-line description. You've already used the built-in skills every time it made you a spreadsheet or a document. The valuable ones are the ones you write yourself, in plain English, about your own work." (framings.md: skill file as institutional memory; this is the same rules-on-disk idea as CLAUDE.md, packaged as a reusable capability. The deck points to "Introduction to Agent Skills" for the deep dive.)

"Most of what Claude needs to know doesn't live in one folder. It lives in your email, your project tracker, your databases. MCP is the standard that connects those, so Claude works with your actual data instead of what you paste in. One practical thing to know: every connection takes up a little of its working memory whether you use it or not, so switch off the ones you don't need." (objections.md: IT/compliance: it sees only what you can see; connecting your email doesn't expose anyone else's, and you can revoke it.)

"Everything else in this session works by asking: you request something, and Claude usually does it. A hook is different. A hook is a rule that runs automatically, every single time, with no exceptions. For example: format every file after it's saved, log every command for the audit trail, block a dangerous action before it runs. The test is simple. If a rule has to hold every time without fail, don't put it in a prompt; put it in a hook." (For these learners the headline is the guarantee, not the syntax: some rules are too important to leave to "usually".)

"To sum up the session: the workflow is the thing to keep. Explore, plan, code, commit, and correct at the plan stage, because that's where a correction costs you a minute instead of an afternoon. Everything else we saw today exists to make that workflow run better. The memory commands keep it focused. CLAUDE.md holds your rules. Skills hold your methods. MCP reaches your data. Hooks guarantee the rules that must always hold. And all of it lives in a folder on your computer, so nothing is lost when a conversation ends."