Welcome. This is a practitioner's manual for Claude Code as it stands in October 2026: a hundred short chapters, each meant to teach you one thing you can use before the kettle boils. It is written for developers and for the technical non-developers who increasingly sit beside them, wondering whether they are allowed to touch the repository. You are. Carefully.
Start with the plain description. Claude Code is Anthropic's agentic coding tool. It reads a codebase, edits files, runs commands and checks its own work, and you drive all of it by conversation. That last part sounds like a chatbot. The first part does not. A chatbot tells you what you might type. Claude Code types it, runs it, reads the error, and tries again.
The difference matters more than it first appears. Autocomplete finishes your sentence; an agent finishes your task. Say you type, in a project directory, claude, and then: the date tests fail every Monday, find out why. It does not guess from the shape of your question. It searches for the tests with Grep, opens the files with Read, runs the suite with Bash, notices that a helper assumes the week starts on Sunday, edits the helper, and runs the suite again to see whether it now passes. You watched; you may have approved a step or two; you did not write the fix. You did, however, still have to decide whether the fix was right. Hold that thought. It is the spine of this book.
The terminal is where it began and where many people still meet it, but it no longer lives only there. The same agent sits in a desktop app with visual diffs, in the browser at claude.ai/code where it runs in a cloud container, inside VS Code and JetBrains, on your phone, in Slack and in GitHub. Later parts walk through each door. For now it is enough to know that the doors open onto the same room: a model, a set of tools, and a loop that keeps going until the job is done or it needs you.
An agent is not a smarter keyboard. It is a colleague who never tires and occasionally misunderstands.
What does that ask of you? Less typing and more judgement. You will spend your time saying what you want with some precision, watching the work go by, and reviewing what comes back. Those are old skills, the ones good editors and good managers have always had, applied to a new kind of collaborator. Some readers find this a relief. Others find it faintly unsettling, like discovering that the dishwasher has opinions. Either reaction is reasonable. Neither is a reason to stay out of the kitchen. Open a terminal in a project you know well, type claude, and ask it a question you already know the answer to. Then see whether it finds the answer the way you would have. That is the cheapest calibration you will ever buy. The terminal learned to talk. Your job is to learn when to listen.
Fig 1 · The Terminal Learned to Talk. An agent finishes the task.
Chapter 2 · Part I
A Short History of a Fast Year
The history is brief because there has not been much time for it. Claude Code appeared as a research preview in February 2025, a command-line tool for people willing to let a model loose in their terminal. It reached general availability in May 2025, alongside the Claude 4 models. By October 2026 it is less a tool than a family of doors onto the same agent: the CLI, a desktop app, the web, IDE extensions, mobile, Slack, a Chrome extension, GitHub Actions, and a Remote Control that lets your phone drive a session running on your own machine.
That is a lot of change for a short stretch of calendar, and it produces a particular kind of anxiety. You learn a workflow on Monday and read on Thursday that someone has a better one. A command you relied on gains a sibling. The model you chose has a newer cousin. If you are the sort of person who likes to finish learning something before using it, this pace is mildly cruel.
The Stoic answer is to separate what moves from what does not. What moves is the surface: commands, menus, which door you walk through, the names of the newest models. What does not move is the shape underneath. An agent gathers context, takes an action, verifies the result and repeats. You tell it what done looks like and you check that it got there. Permissions decide what it may do without asking. Memory files tell it what it should already know. Those ideas were true in the preview and they are true now. Learn them properly and the rest is vocabulary.
There are also a few practical habits that turn the pace from a threat into weather. If you install with the native installer, Claude Code updates itself, so you are rarely more than a short while behind. When something new appears, type /help inside a session rather than hunting through threads of other people's enthusiasm. When something behaves oddly after an update, /doctor will examine your setup and tell you what it finds. And when you read a confident blog post about a feature, check whether the post is older than the feature's last change. Plenty are.
Fast tools reward slow principles.
There is a temptation, in a fast year, to adopt everything. Resist it. Each new surface is useful to somebody, but not every one is useful to you this month. Pick the door you will actually walk through each day, learn its habits, and add the next only when you feel a specific absence. A developer who uses the CLI well will be more productive than one who has installed every extension and trusts none of them.
The pace will continue. That is not a forecast, merely an observation about the last twenty months. You cannot slow it down and you do not need to keep up with all of it. You need to keep up with the part that touches your work, and to know where the rest is written down when you need it. Novelty is cheap. Fluency is the thing that compounds.
Fig 2 · A Short History of a Fast Year. What moves, and what stays.
Chapter 3 · Part I
Gather, Act, Verify
Every Claude Code session, however grand or trivial, runs the same loop. It gathers context, takes an action, verifies the result, and repeats until the task is done or it needs something from you. Once you can see the loop, you can steer it. Until you can, the agent looks like a magician, and magicians are hard to correct.
Gathering is the quiet part. Ask it to add rate limiting to an API and it will not start writing. It will use Glob to find the route files, Grep to find where requests are handled, and Read to open the middleware you already have. It might check the package manifest to see what libraries are installed. This is the agent doing what a sensible new hire does on their first morning: looking around before touching anything. If the gathering is thin, the work will be confident and wrong. You can help by pointing at things directly, with an @path mention such as @src/middleware/auth.ts, so it starts in the right room.
Acting is the part people come for. Claude edits a file with Edit, creates one with Write, or runs a command with Bash. Depending on your permission mode, some of these will pause and ask you first. In the default mode, shown as Manual, it asks before edits, commands and network access. That pause is not bureaucracy. It is your chance to see the action before it happens, which is the cheapest moment to object.
Verifying is the part that separates an agent from a well-read autocomplete. After an edit, Claude will run the tests, start the build, call the endpoint, or read the file back to see whether the change landed as intended. If something fails, it reads the failure and goes round again. The quality of this step depends heavily on whether verification is possible at all. A project with a test suite gives the agent a mirror. A project without one gives it only its own opinion, which is about as reliable as yours at two in the morning.
So tell it how to check. Add rate limiting to the login route, then run npm test and show me the output is a better instruction than add rate limiting, because it names the finish line. You will be surprised how often the difference between a good session and a muddled one is a single sentence about verification.
The loop is only as honest as its last step.
You are allowed into the loop at any point. Press Esc and Claude stops what it is doing; you can redirect it without losing the session. You can also type while it works and your message waits in a queue until it next looks up. If it has gone somewhere you did not want, press Esc twice, or use /rewind, to return code and conversation to an earlier checkpoint. None of this is rude. It is how the collaboration is meant to work. Watch three or four sessions with the loop in mind and you will start to notice where yours go wrong. Usually it is the first step or the last. The middle, oddly, tends to take care of itself.
Fig 3 · Gather, Act, Verify. Every session runs one loop.
Chapter 4 · Part I
Installing Without Ceremony
Installation is the least interesting part of Claude Code and should take the least of your time. There are a handful of routes, all of them short, and the right one is whichever you will not have to think about again.
The recommended route is the native installer. On macOS, Linux or WSL, open a terminal and run curl -fsSL https://claude.ai/install.sh | bash. On Windows there is an equivalent PowerShell one-liner in the official documentation. The virtue of the native install is not speed but maintenance: it keeps itself up to date in the background. Given how quickly the tool changes, that is worth more than it sounds. A stale install is the most common reason a chapter like this one appears not to match your screen.
If you prefer a package manager, there are two well-trodden paths. On a Mac, brew install --cask claude-code works as you would expect. On Windows, WinGet will do the same job. These are perfectly good choices for people who manage everything through one tool and like it that way. Just be clear in your own mind about who is responsible for updates, because a cask you never upgrade will age quietly while the documentation moves on without it.
Choose the install you will forget about, then forget about it.
Once installed, go to a project directory and type claude. The first run asks you to sign in. You need either a Claude subscription, such as Pro, Max, Team or Enterprise, or API billing through an Anthropic key or a cloud provider. Pick the one that matches how you or your organisation already pays; the next part of this book has a chapter on the difference. Once that is done, the prompt is waiting and the real work can begin.
Now the part nobody mentions until it goes wrong. Sometimes it sulks. The command is not found, or it starts but cannot authenticate, or it behaves as though a setting you made does not exist. Before you search the internet, run /doctor inside a session. It diagnoses your installation and configuration and tells you what it finds, which is usually something mundane: two copies installed by two different routes, a path that does not include the binary, a settings file with a stray comma. /status is its gentler companion, worth a glance when you suspect the session is not set up the way you believe it is.
A small amount of hygiene pays off here. Install by one route only; if you switch, remove the old one. Keep your shell's path tidy. If you work across several machines, use the same method on each, so that a problem on one has the same answer on the others. And if you are setting this up for a team, write the install step into the project's onboarding notes, in one line, so that the next person does not invent a sixth method. None of this is glamorous. That is rather the point. The best installation is the one you never have to remember doing.
Fig 4 · Installing Without Ceremony. Install once, then forget it.
Chapter 5 · Part I
Your First Five Minutes
Pick a repository you know reasonably well. Not the most important one in the company, and not a toy you made last night; something in between, where you would recognise a wrong answer. Open a terminal there and type claude. You are now in a session, and the cursor is waiting for you to say something sensible.
Begin by asking it to explain the codebase. Something like: Explain how this project is organised, as if I am starting here on Monday. Where does a request come in, and where does data get stored? Watch what it does before it answers. It will list files, search, and open a few of them. The answer that comes back is a useful test of two things at once: whether the agent reads well, and whether your project is legible. If it gets the structure wrong, it may be the agent; it may also be that your structure is genuinely confusing, which is worth knowing.
Next, make one tiny change. Not a feature; a small, checkable improvement. Fix a misleading error message, add a missing --help description, correct the setup step in the README that everyone silently skips. Be specific: In @README.md, the install section says to run make setup but the Makefile has no such target. Fix the instructions to match the Makefile. Specific requests produce small diffs, and small diffs are the ones you can actually review.
When it wants to edit, it will ask. In the default permission mode, shown as Manual, every edit and command waits for your approval. On a first session, this is exactly what you want. Read each proposed change as it appears. If the wording is wrong, say so in plain language and let it revise. You are not being fussy. You are calibrating.
The first diff you approve teaches you more than the first ten you skim.
Then review the change as a whole. In the terminal, ask it to show the diff, or run git diff yourself. If you prefer something more visual, the desktop app and the VS Code extension both show changes inline. Look for the edits you asked for, and then look for the ones you did not. An agent being helpful sometimes tidies a neighbouring line while it is there. That may be fine. It should never be a surprise. Finally, commit. You can ask Claude to do it, and it will write a reasonable message, or you can do it yourself to keep the ceremony in your own hands. Either way, the change is now in git, which matters because git is your real safety net. Claude Code keeps its own checkpoints of edits, but those are a convenience, not a history.
Five minutes, one explanation, one small change, one honest review, one commit. That is the whole shape of the work, in miniature. Larger tasks are mostly the same shape with more patience in the middle. If the session went well, try a slightly larger change tomorrow. If it went badly, look at where: usually the request was vaguer than it felt when you typed it. Begin small. The agent will not be offended, and neither will your colleagues.
Fig 5 · Your First Five Minutes. Five minutes, one honest review.
Chapter 6 · Part I
Tools Are the Hands
A model on its own can only produce text. What turns it into an agent is a set of tools: named, narrow capabilities that let it touch the world. Claude Code's tools have plain names, and it is worth learning them, because those names are also the handles by which you grant and refuse permission.
The reading tools come first. Read opens a file. Glob finds files by pattern, so it can answer where are all the test files? without opening anything. Grep searches file contents, which is how Claude finds every caller of a function before changing its signature. These three are how the agent gathers context, and they are mostly harmless: looking is not touching. The writing tools are Edit, which changes part of an existing file, and Write, which creates a file or replaces one entirely. The distinction is practical. An Edit is a surgical change you can review line by line. A Write is a whole new page, and deserves a slightly harder look.
Then there is Bash, which runs shell commands. Bash is the most powerful tool in the box and therefore the one to think about. It is how Claude runs your tests, starts your build, installs a dependency or checks git status. It is also, in principle, how it could delete a directory. Most of the permission machinery you will meet later exists because of Bash.
Two tools reach outside your machine. WebFetch retrieves a specific page, such as the current documentation for a library whose API changed last month. WebSearch looks things up when Claude does not know the page. Finally, Agent spawns a subagent: a separate worker with its own context that goes off, does a piece of research or work, and returns only its report. You will meet subagents properly in a later part. For now, know that they keep the main conversation from filling up with every file a search touched.
A permission rule is only as precise as the tool name inside it.
Here is why the names matter. Permission rules in a settings file are written against them. "allow": ["Bash(npm test)"] lets Claude run your test command without asking. "allow": ["WebFetch(domain:github.com)"] lets it read GitHub pages freely. "deny": ["Bash(rm -rf *)"] forbids a particular kind of disaster outright, and deny beats allow in every mode. You can see and edit these rules with /permissions. Tools that come from MCP servers follow a pattern too, appearing as mcp__<server>__<tool>, so they can be allowed or denied by the same method.
When a permission prompt appears, it names the tool and shows what it wants to do. Read that line. Over a week you will notice that you approve the same few things again and again, usually test runs and reads, and those are good candidates for an allow rule. The prompts you rarely see are the ones worth keeping as prompts. Learn the hands, and you will know which ones to tie and which to leave free.
Fig 6 · Tools Are the Hands. Tool names are permission handles.
Chapter 7 · Part I
Choosing a Mind
Claude Code runs on Claude models, and you get to choose which. In late 2026 the family includes Opus 5.5, Sonnet 5.5, Haiku 4.5 and Fable 5.1. The documentation describes what each is for, and it changes as the family grows, so treat any summary here, including mine, as a starting point rather than a law. Switching is simple. Type /model in a session and pick from the list. The choice holds for that session, and you can change it halfway through if the work changes character. You can also set a default in your settings file under the model key, so that every new session starts where you usually want it.
The second dial is effort. /effort sets how deeply the model reasons before it acts, with levels such as low, medium, high, xhigh and max. Higher effort means more thinking: more careful plans, more consideration of edge cases, and more tokens and time spent getting there. Lower effort is brisk. Neither is better in the abstract. A renamed variable does not need deep thought, and a concurrency bug in a payment flow does not deserve a quick one.
The useful habit is to pick by task, not by vanity. There is a strong pull towards always using the largest model at the highest effort, on the theory that one should not economise on intelligence. The theory sounds noble and works poorly. A heavyweight model at maximum effort, asked to fix a typo, will fix the typo after a pause long enough to make you wonder whether it has died. Meanwhile your usage drains for nothing. Match the mind to the job: a capable all-rounder for daily work, more depth when the problem is genuinely hard or ambiguous, something lighter and faster for mechanical chores.
The right model is the cheapest one that does the job well.
There is also the matter of context. Supported models offer a window of up to a million tokens, which is large enough to hold a substantial codebase plus a long conversation. It is tempting to treat this as permission to stop thinking about context at all. Do not. A large window means fewer interruptions, not infinite attention. A model given everything still has to find what matters, and a session cluttered with three abandoned approaches is harder to steer than a fresh one. Use /context to see what is filling the window, and /clear when you change subject.
A good working pattern looks like this. Start the day on your usual model at a moderate effort. When a task resists, when the agent goes round the loop twice without progress, raise the effort before you change anything else, because depth is often what was missing. When you hit a run of routine changes, lower it again. Treat the dials as you would the gears on a bicycle: you change them for the hill, not for your self-image.
Nobody will award you a medal for using the biggest model on a README fix. Choose the mind the task needs, and save the heavy thinking for problems that have earned it.
Fig 7 · Choosing a Mind. Pick the mind by the task.
Chapter 8 · Part I
Paying for the Privilege
Claude Code costs money, and it is better to understand how before the bill or the limit introduces itself. I will not quote prices here. They change, and a book that quotes them ages faster than milk. What does not change much is the structure.
There are two ways to pay. The first is a Claude subscription: Pro, Max, Team or Enterprise. You sign in with your Claude account and your use of Claude Code draws on that plan. The second is API billing, either with an Anthropic API key or through a cloud provider your organisation already uses. Here you pay for what you consume. Subscriptions suit individuals and teams who want predictability. API billing suits organisations that already run their spending through a cloud account, and automated work that needs to be metered precisely. Many teams use both: subscriptions for people, API billing for pipelines.
Either way, there are usage limits. A subscription is not an unlimited buffet; plans have allowances, and heavy days can reach them. API billing has its own constraints. The exact numbers belong in the documentation, which will be current when this chapter is not. What matters is that a limit exists, and that you can see how close you are to it.
Two commands help. /cost shows what the current session has spent. /usage shows how much you have used. Glance at them at the end of a long session for a week and you will develop an instinct for which kinds of work are expensive. It is rarely the ones you expect. A session that reread the same huge log file twelve times will outspend a session that wrote a whole feature.
Spend attention before tokens. Attention is cheaper and it compounds.
That line is the practical heart of this chapter. Most waste is not caused by a big model or high effort. It is caused by vague requests. Make the dashboard better invites the agent to read everything, try several things and ask what you meant. Make the dashboard's loading spinner appear only after 300 milliseconds, in @src/components/Dashboard.tsx costs a fraction of that, and produces something you can review in a minute. Thirty seconds of your thinking replaces many minutes of its exploring.
A few other habits help. Use /clear when you change subject, so the next task does not drag the last one's context along with it. Let /compact summarise a long session rather than carrying every exchange forward. Choose effort deliberately, as the previous chapter suggested. And if you find yourself repeating the same explanation every session, put it in a CLAUDE.md file once, which a later part covers at length. None of this is miserliness. It is the same discipline that makes a good brief to a contractor: clear scope, known finish line, no paying anyone to wander around the building looking for the problem. The agent does not mind wandering. Your budget does. Money spent on clarity is the only kind you never regret.
Fig 8 · Paying for the Privilege. Spend attention before tokens.
Chapter 9 · Part I
What It Is Bad At
Every honest manual has a chapter on failure, and this is it. Claude Code is very good at a great many things. It is also bad at a few, and the trouble is that it is often bad at them in the same calm, fluent voice it uses when it is right. Knowing the shapes of its failures is the beginning of using it well.
The first is confident wrongness. The agent will occasionally tell you a function does something it does not, or report that tests pass when it ran the wrong tests, or explain a bug with a story that is coherent and false. This is not lying. It is the nature of a system that produces plausible text, and plausible is a different property from true. The defence is not suspicion of everything; that would be exhausting. The defence is evidence. Ask it to show you the test output, not to describe it.
The second is stale assumptions. The model learned from data with a cutoff, and libraries move. It may reach for an API that was renamed last spring, or a configuration option that has since been removed. When something fails in a way that smells of version drift, point it at the current documentation with WebFetch, or tell it which version you are on. It adapts quickly once it knows. It cannot know what it has not been shown.
The third is vague tasks. Clean up this module has no finish line, so the agent will invent one, and it may not be yours. It might rename half the variables, extract three helpers and rewrite a working loop for elegance. Each change is defensible; the total is a diff nobody wants to review. Vague tasks are not the agent's failure so much as a joint one, but it is the agent's output you will be cleaning up.
Fluency is not accuracy. Treat a smooth answer as a draft.
The fourth is taste. Claude can tell you a design is inconsistent, and it can follow a style guide with real care. What it cannot do reliably is know which of three reasonable approaches your team will still like in a year, or that your users hate a particular kind of modal, or that the elegant abstraction is wrong because the product is about to change direction. Taste is accumulated context about people and consequences. You have more of it than any model, and you should keep exercising it.
The antidote to all four is the same: verification. Make sure there is a way to check the work, and use it. Tests, a running build, an actual request against the endpoint, a careful read of the diff. Plan mode helps too. Press Shift+Tab until it shows, and Claude will read and propose without editing, so you can correct a wrong assumption before it becomes forty changed lines. And when the answer feels too neat, ask it to argue against itself. It is surprisingly good at finding the hole in its own story when invited to look. The agent is not unreliable. It is reliable in the way a capable stranger is: useful from the first hour, and trusted in proportion to what you have checked.
Fig 9 · What It Is Bad At. Fluent is not the same as right.
Chapter 10 · Part I
Delegation, Not Autocomplete
Everything in this part comes down to one shift in how you see your own role. With autocomplete, you are still the author; the tool suggests the next word and you accept or reject it. With Claude Code, you are something else. You are the person who decides what should be done, hands it over, and judges what comes back. You have become the editor.
This is not a demotion. Editors have always been the people who know what the piece is for. They do not write every sentence, but they decide which sentences survive. In software terms, you define the task, the constraints and, above all, what done looks like. Then you read the diff the way an editor reads a draft: for whether it does what was asked, whether it does anything that was not, and whether it would embarrass anyone in six months.
Defining done is the skill that pays off most. A good definition names a check that can actually be run. The import handles files with a byte-order mark; add a test with such a file; the suite passes is a task with a finish line. Make imports more robust is a mood. When you give the agent a finish line, it can verify its own work in the loop, and your review becomes a confirmation rather than an investigation.
Delegation is the art of saying exactly what you want, and then checking that you got it.
There are things you should keep. Decisions that are hard to reverse, such as deleting data, publishing a release or changing an interface other teams depend on, remain yours. Judgements of taste remain yours. So does the final read of anything going out under your name. The permission system, which a later part covers, exists to make these boundaries explicit: the agent may run the tests without asking, but must ask before it pushes.
There are also things you should let go of, and many people find this harder. You do not need to type the boilerplate, hunt for every caller of a function, or remember the flag for that one command. You do not need to watch every step once you trust the loop for a given kind of task. Hovering over a delegate is a familiar failure in human teams, and it is the same failure here: it costs your attention and teaches you nothing new.
So the working stance for the rest of this book is simple to state and takes a while to practise. Say what you want with precision. Say how it will be checked. Let the agent work. Review what it hands back as an editor would, honestly and with your name on it. Over time you will widen what you delegate, not because the agent has changed but because you have learned where it is reliable. The ground floor is laid. You know what the tool is, how its loop runs, what its hands are called, which mind to choose, what it costs and where it stumbles. Everything above this floor is detail and leverage. You stopped being the typist. You are still, and always, the one who says it is finished.
Fig 10 · Delegation, Not Autocomplete. From author to editor.
Free preview · Part I
Keep reading
You have read the first 10 of 100 chapters of Claude Code: The Ultimate Guide 2026. The full book has every chapter and plate, as PDF and EPUB in English, French, Polish and Spanish.