Claude Code: fundamentals of the daily driver

Everything this course has taught — models, prompts, tools, agent loops, MCP — ships assembled in one product you can use today: Claude Code, Anthropic's agentic coding tool. It runs in your terminal, your IDE (VS Code and JetBrains extensions), as a desktop app, and on the web — same harness, different ergonomics — reads your codebase with real tools, and works in the loop you built by hand in the agents lesson, production-hardened. This lesson is the operating manual: the three lessons after it cover power features, automation, and where it fits in the wider lifecycle.

CLAUDE.md: the project's standing memory

Every session starts fresh — except for one file. CLAUDE.md, checked into your repo root, is loaded into context automatically, making it the one place where knowledge survives between sessions and transfers between teammates. Run /init in a new repo and Claude drafts one from what it finds; from then on, curate it like the onboarding document it is:

# Acme API — Claude context

- Python 3.12 / FastAPI / Postgres. Tests: `make test` (unit), `make itest` (needs Docker).
- Run `make lint` before any commit; CI rejects unformatted code.
- Money is integer cents everywhere. Never float. Never "fix" this.
- `legacy/billing/` is frozen for a migration — do not refactor it.
- Auth middleware ordering in `app/middleware.py` is load-bearing; change it only with a test.

Commands, conventions, invariants, landmines. Keep it short and true — a bloated CLAUDE.md gets skimmed the way bloated onboarding docs do — and when Claude does something wrong that a sentence would have prevented, add the sentence. That habit turns every mistake into a permanent fix, and it is the memory-surface principle from the context lesson applied to your daily tool.

Permissions: the harness's trust dial

Claude Code asks before running commands or editing files, and the permission system is the promote-and-gate pattern from the agents lesson running on your laptop. You widen trust deliberately: allow specific safe commands permanently (the test runner, the linter), keep confirmation on anything destructive, and use plan mode when you want analysis with a hard guarantee of no changes at all. The discipline to keep: permissions are per-project configuration, checked in and reviewed like everything else — not a global "yes to everything" reflex. The escape hatch of skipping permissions entirely exists for one context only: sandboxed containers where the blast radius is already contained.

Steer the workflow, not just the request

The difference between mediocre and excellent results with Claude Code is rarely the model — it is how the work is framed:

• Explore, plan, then code. For anything non-trivial, have Claude investigate and propose a plan before writing code — plan mode exists for exactly this. Reviewing a plan takes a minute; unwinding a wrong implementation takes an afternoon.
• Give it a feedback loop. Claude is dramatically stronger when it can check its own work: point it at the test suite, the type checker, the linter — and ask it to run them and iterate until green. An agent with a verifier converges; an agent without one guesses.
• Complete specification up front. One well-specified request — goal, constraints, definition of done — beats ten rounds of drip-fed clarification, in both quality and tokens. You learned this as a prompting principle; here it becomes muscle memory.
• Use the multimodal input. Paste a screenshot of the broken UI, the failing dashboard, the design mockup — the vision lesson applies fully, and "make it look like this" with an image beats paragraphs of description.
• Course-correct early. Interrupt the moment a direction is wrong. Ten more minutes of a wrong trajectory is ten minutes of cleanup.

Context hygiene, in practice

Claude Code sessions accumulate context exactly as the context lesson described — every file read, every command output. Two commands are your manual controls: /clear resets the conversation for a fresh task (the single most under-used command), and /compact summarizes a long session you want to continue. The instinct to build: one task, one session; when the task changes, so should the context.

What to take into the next lesson

CLAUDE.md as versioned memory, permissions as a deliberate trust dial, plan-first workflows, feedback loops, early correction, deliberate context hygiene. That is Claude Code as a very good pair programmer. The next lesson is where it becomes your tool rather than a generic one: skills, hooks, subagents, and the extension points that encode how your team works.