Claude Code Basics
Claude Code explained from scratch: what it is, how it differs from Claude Chat and Cowork, and how to actually use it — even without opening a terminal.
Lessons
46 lessonsThe Claude Ecosystem and Where Claude Code Fits
Chat, Cowork, and Code aren't the same thing: a map of the Anthropic ecosystem, and why Claude Code, built for coding, is useful even if you don't code.
What Claude Code Is: The Collaborator Who Walks Into Your Studio
Chat answers you; Claude Code walks in and works: what that means in practice, where to find it, and the limits worth keeping in mind.
How an Agent Works: The Loop
It thinks, reaches for a tool, checks how it went, and decides the next move. The loop that turns a reply into finished work — and how you know it's done.
Claude Code in Action: The Loop, for Real
We ask it to build a small dashboard and watch the loop run: what happens on screen, what to recognize, and what shouldn't worry you.
The Model Has No Memory: It Starts Over Every Time
The model remembers nothing from one step to the next. Why it seems otherwise, who feeds it memory, and what that changes for you in practice.
The Harness: The Engine and the Gear Around It
Same engine as chat, different results: what the harness is, what it does on every loop, and why it — not the model — is what makes Claude Code so effective.
The Map: Four Buckets
Everything you'll see in this course, on one map: the engine, the four questions you'd ask about any collaborator, and the order we'll tackle them in.
There's No Single Claude: The Model Lineup
Haiku, Sonnet, Opus, Fable: what actually changes from one model to the next, and why "most powerful" doesn't mean "best for you."
Which Model for Which Job
One question decides it: does this job need understanding, or just doing? The practical criterion and the rule that keeps you from getting it wrong.
Effort: How Hard It Should Think
A dial separate from the model: how much effort to put into an answer. What changes between low and high effort, and when it's worth turning up.
Model or Effort? The Question That Trips Everyone Up
It overdoes it, or it slacks off: two symptoms that almost always come from effort, not the model. How to tell which of the two dials to turn.
The Bill: Why Saving Money Can Cost You More
The cheap model, corrected five times, costs more than the expensive one that nails it on the first try. What actually drives cost, and why you don't swap engines mid-session.
Where to Run It: Four Doors In
Terminal, editor, browser, or desktop app: four ways into the same tool. Which one to pick if you're starting from zero, and what stays the same across all of them.
What You Need Before You Start
Account and plan (the free tier isn't enough), your computer's requirements, and what you don't need: no language to install, no programming background.
Installing Claude Code
Two paths, one without a terminal and one with a single command. How to launch it the first time, log in, and check that everything's in order.
The Folder: Where You Open It Decides What It Works On
Claude Code works inside the folder you open it in. Why opening it in the right place is the most important choice of your first week.
Choosing the Engine, in Practice
The move for switching models inside a session, and the one for checking how much context you're using. Chapter 3's theory, put into practice.
Your First Task: Small, Yours, and It Works
Pick a task that's sure to succeed, watch it work, and understand what just happened — including the permission request you'll see pop up.
Why It Asks for Permission
What goes through without asking, what always stops, and what happens when you say no. The exact point in the loop where you get a say.
The Rules: Always Yes, Ask Me, Never
Three answers you give once so you never have to give them again. Where the rules live, which one wins when two contradict each other, and why writing them into instructions isn't enough.
The Modes: How Much Leash You Give It
A scale from "touches nothing" to "never asks": what each mode does, when it's worth stepping up a notch, and the one you should never use on your own computer.
Plan Mode: Get the Plan Before the Work
Before you let it work, have it explain what it would do. The cheapest way to catch it when the two of you understood different things.
Verification in the Loop: Give It a Yardstick
A screenshot, a reference file, a checklist: how to give it a way to tell for itself whether the job's done well or badly.
Example: Putting the Bucket Together
A real job from start to finish, with plan, permissions, and verification each in place — and what changes compared to launching it and hoping.
CLAUDE.md: The Notes It Reads the Moment It Walks In
The file that stops you from repeating yourself every session: what it is, where it goes, and how to get it almost written for you.
How to Write a CLAUDE.md That Actually Works
Short, specific, checkable. Why a long file makes results worse instead of better, and what actually belongs inside it.
The Context Window: How Much It Can Hold at Once
The space the model has to hold everything together. What fills it up, why more stuff doesn't mean better answers, and how to keep an eye on it.
Cleaning Up: Compact and Clear
Two moves so you're not dragging half a day of conversation behind you: when to summarize, when to start fresh, and what survives either way.
Automatic Memory
Claude takes its own notes on how you work. What it saves, where those notes end up, how to read them, and how to delete them when it got you wrong.
Example: From Repeating Yourself to Never Again
Three sessions of the same job: the first explaining everything, the second with instructions written down, the third with memory doing the rest.
What a Skill Is: A Procedure Written Once
Not a function to code: a sheet of instructions Claude follows when it's needed. The difference between always-on instructions and on-demand procedures.
Creating Your First Skill
A folder, a file, two lines of header. How to write it, where to put it so it applies everywhere or just here, and how to call it up.
The Description Decides Whether It Gets Used
Claude knows nothing about a skill's body until it's needed — it only reads the description. That's why it's the single most important line in the file.
Example: A Skill That Saves You the Week
We take something you redo the same way every time and turn it into a procedure you can call up with a single word.
The Subagent: A Helper With Its Own Desk
Sending someone off to do the dirty work in another room and getting back only the result, keeping your own desk clean.
When a Helper Is Worth It (and What It Costs)
It isn't free: every helper starts from zero and has to rebuild its own context. The criterion for knowing when to delegate and when to do it yourself.
Teams: When Agents Talk to Each Other
Several agents coordinating over a shared task list. What it is, how it differs from subagents, and why you almost never need it.
Example: Searching Without Cluttering the Desk
The same job with and without a helper, to see concretely what changes in the result, not just in how it's organized.
MCP: The Standard Plug Into Your Tools
Connecting Claude Code to your email, your management software, your cloud documents. What the protocol is, when you need it, and who to trust.
Plugins: Packaging Up and Borrowing
A box that bundles skills, helpers, connections, and automations: how to install someone else's, and how to share your own.
Example: When You Stop Copying and Pasting
A job that used to be all copy-paste between two windows, redone with the tool connected directly.
Hooks: The Thing That Always Happens
Instructions guide, permissions forbid, hooks guarantee. The third kind of control — the one that doesn't depend on the model's judgment.
Where It Fires and What It Can Do
The points in the loop where you can hook in an automation: at startup, before a tool, after, once the job's done — including the power to block it.
When You Actually Need One (and When It's Too Much)
The criterion for choosing between an instruction, a permission, and an automation — and why it's perfectly fine to finish the course without writing a single one.
The Project: Your Expense Tracker
The final task: build yourself a small personal expense tracker from scratch, using everything you've learned. The rules of the game and how to set it up.
Wrap-Up: What You're Taking Home
The full map, the three instincts worth more than any feature, what we left out on purpose, and where to go from here.