How to Use Claude Code: Guide, Tutorial and Pitfalls to Avoid (2026)

Claude Code is an agent, not a chat

With Claude's chat (claude.ai), you ask a question, read the answer, then copy what you want into your files yourself. Claude Code does that work for you.

You start it from a folder on your computer. It can then read and change the files in that folder, or create new ones. It can also run commands, the typed instructions that make a computer act, such as the one that starts your site so you can test it.

Say you tell Claude Code that the Send button on your form does nothing. It looks for the file that handles that button, reads it, fixes it, then reloads the page to see whether the button works.

That kind of program is called an agent: an AI model given tools (read a file, run a command, and so on) that keeps taking actions until the task is done. The AI model is the program that understands your request and decides what to do. Anthropic describes three phases that repeat: gather context (find and read the useful files), take action (change files, run commands) and verify the result.

In the rest of this guide, "Claude" alone means the agent working inside Claude Code. "Claude's chat" means the version you talk to in a browser.

A session is one conversation with Claude Code, opened in one folder, from the moment you start it until you close it or empty it with /clear. (/clear is a slash command: a Claude Code instruction that starts with / and is typed in the conversation, like a message.)

A new session doesn't remember earlier conversations. It only knows what's written in two files: CLAUDE.md (your instructions, which it rereads at every session) and Claude's auto memory, notes it takes on its own. The exception is an old conversation you choose to resume: Claude then finds what was said in it.

Here is what Claude Code can reach when you start it in a folder:

• Your project. Every file in the folder and its subfolders, which is why a folder should hold one project only. Through its commands, Claude can also reach other files on your computer.
• Your computer, through commands. Whatever you could type in the terminal yourself, including what installs software or sends your work over the internet.
• Your project's history. If your project is tracked by Git, the program that keeps each version of your files, Claude can save a version, compare two versions or go back. It can also send that history to GitHub, an online service that keeps a copy.
• The CLAUDE.md file. If your project has one, Claude rereads its instructions at the start of each new session.

The AI model itself runs on Anthropic's servers. So Claude Code needs an internet connection, and the files it reads go to those servers to be processed.

Do you need to know how to code? No. Several people who don't code build working software with Claude Code. Georg Ell runs Phrase, a translation software company, and had never built software. In early 2026 his CFO showed him a tool for writing price quotes, which the CFO had built himself. Ell installed the Claude app that evening.

In Claude's chat, he began by asking how to use it. He believed Claude Code was "not for me" until he opened it in the app and asked it the same questions. Six weeks in, he had built an app that writes a course on any topic for anyone at his company, in about eight to ten hours. His summary, in an April 2026 interview: "All I've done is ask questions. I still don't understand half of what I'm doing."

Flavie Prévot runs Le Board, a French incubator for entrepreneurs, and doesn't code either. With Claude Code she built the incubator's app, where each member enters their revenue and compares it with the group's average. She dictated her requests in the desktop app, told Claude what wasn't right, then asked for the next change, over several weekends, without opening a terminal.

In September 2026 she said the hard part was "not at all" the technical side, even with "the coding environment to set up, the software to install", meaning the programs a project needs in order to run. Her conclusion: "what's complicated is knowing what you want."

A first version can come fast. Pierre Guilbaud trained in marketing and sales and had never coded. With Claude Code he built working online software in three days, to help people write LinkedIn posts. He launched it less than a month after the idea, as he told in his own video of May 2026.

Feeling at ease takes longer. Nomiki Petrolla isn't a developer, yet she builds every screen of Theanna, software for founders growing a business, with Claude Code. In April 2026 she wrote that it took her "a few weeks to get fluent."

These people don't agree on how far someone who doesn't code should go alone. Georg Ell says customers "can be reassured that I'm not touching our production code", the code that runs his company's live product. Pierre Guilbaud opened his software to the public without a developer. With a developer or without, ask Claude for a security review before customers trust you with their data, and add a developer's review if that data is sensitive.

What you need first: a paid plan and a place to run it

Claude Code needs two things before you can use it: an account that includes it, and one of the two places where a beginner runs it. On 3 November 2026, Anthropic's documentation says it plainly: "The free claude.ai plan does not include Claude Code access." You need a paid plan, or a Console account, Anthropic's pay-as-you-go service with no subscription.

What each plan allows can wait until you've seen Claude work. Next comes the place to run it. Claude Code exists in several programs, but two matter when you start. Both run the same agent, on the same account, with the same limits.

The desktop app. It shows in color what Claude changed. Above all, it has a preview: when Claude starts your site on your computer to test it, the app opens it in a browser pane, next to the conversation. You can click around in it like a real site.

According to Anthropic's documentation, after each change Claude checks its own work in that pane: it takes screenshots, looks for error messages and confirms the page works. Anthropic calls this auto-verify, and it's on by default.

Claude checks your own specific case (say, a cart of 3 items that must show the right total) only if your request describes it. To show Claude what's wrong, you can also drag a screenshot into the conversation.

Friends I've worked with several times use this app and are very happy with it. I've watched them use it while working alongside them, and it's very well made. If you're not at ease with a terminal, I find it ideal.

Download the Claude app for Mac or Windows at claude.com/download (a Linux version exists in beta), install it and sign in. Click the Code tab. In the row under the box where you type, click the first control and pick the top entry in the "Local" group. Local means your own computer rather than a machine at Anthropic. You then choose your project's folder with "Open folder…".

The app brings its own copy of Claude Code, so you have nothing else to set up. Jason Lee, who teaches app building with Claude Code on YouTube, works this way: the desktop app, the Code tab and one folder per project, so everything stays together (video of July 2026).

Shubham Sharma, a former startup developer who now trains teams on AI coding agents, points to "a trap everyone falls into": starting on claude.ai/code, the browser version. That version doesn't touch the files on your computer. It runs on a machine at Anthropic, on a copy of your project that you must first put on GitHub. Your file of secret keys, which holds the access codes to your accounts, isn't there. The browser version also has fewer features.

The terminal. Anthropic asks for macOS 13 on a Mac, Windows 10 (version 1809) on a PC, or Ubuntu 20.04 or Debian 10, two kinds of Linux. You also need 4 GB of memory and an internet connection, in a country where Anthropic offers its services (the United States is one).

On a Mac, open the Terminal app (Cmd+Space, then type "Terminal"). On Windows, open PowerShell, the Windows terminal (Windows key, then type "PowerShell"). If you've never opened one, Anthropic's documentation has a terminal guide. Then paste the command for your system and press Enter. It downloads and runs the installer from Anthropic's own site.

On a Mac, on Linux or in WSL (the Linux built into Windows):

curl -fsSL https://claude.ai/install.sh | bash

On Windows, in PowerShell:

irm https://claude.ai/install.ps1 | iex

The command shows no progress while it downloads, Anthropic's documentation warns. Wait until you can type again, then open a new terminal window, because the old one doesn't yet know where to find Claude Code. Then type:

claude --version

If all went well, the answer is a version number followed by "(Claude Code)", such as 2.1.317 (Claude Code), the version of 3 November 2026. If the terminal says claude can't be found, your computer doesn't yet know where to look for the program: Anthropic's troubleshooting page gives the fix for each system.

If something doesn't work, claude doctor checks the installation and settings without starting Claude. Inside a Claude Code session, /doctor goes further: it looks for installation, settings and CLAUDE.md problems, then offers fixes that Claude applies once you agree.

If you've read other guides, four corrections:

• Node.js isn't required. Node.js runs programs written in JavaScript, a programming language, outside a browser. Anthropic's installer (the curl or irm command) already contains everything needed. Only the other way of installing Claude Code, through npm (the program that installs Node.js software), needs Node.js. That way now requires Node.js 22 at least: guides that say 18 are old.

• Windows doesn't require WSL. Claude Code installs directly from PowerShell, with no administrator rights. Only the sandbox, the protection for content from other people, needs WSL 2, the current version of WSL.

• Git isn't required to install Claude Code. On 3 November 2026, Anthropic's setup page calls it optional, while other guides list it as a prerequisite. You'll still need it from your first session, because Git keeps your project's versions and is what lets you undo.

  On Windows, add Git for Windows now (git-scm.com/downloads/win, keep the default options). Anthropic recommends it, and you'll need Git anyway. Without it, Claude Code runs its commands in PowerShell instead of Bash, the command language it uses on Mac and Linux.

• Installed through Homebrew or WinGet, Claude Code doesn't update itself. These software managers, on Mac and on Windows, can also install Claude Code. By default, you have to rerun their update command from time to time. Anthropic's installer, by contrast, updates Claude Code in the background.

Your first session: the Claude Code tutorial, step by step

Now that Claude Code is ready, this tutorial follows your first session, from opening a folder to keeping or undoing your first change. The goal is to prepare your project and see how Claude works, with as little risk as possible. Each step has its proof, the sign that it's done. It also has its trap. The order is the same whether you start from nothing or from an existing project.

1. Open a folder. If you're starting from nothing, first create an empty folder, for example "my-site" in Documents. In the app, choose that folder with "Open folder…" under the box where you type. In the terminal, type cd ("change directory") followed by a space, then drag the folder onto the terminal window so its location writes itself. Press Enter, type claude and press Enter again.

In the terminal, the first time, a sign-in page opens in your browser: choose your Claude subscription, or the Console if that's what you took.

Claude Code also asks whether you trust the files in this folder. If you say yes, it applies the settings stored in this project's .claude folder. Those settings can let Claude run certain commands without asking. They can also contain hooks, commands that run on their own, for example when a session opens. Answer yes for your own project.

For a project you got elsewhere, from GitHub or in a ZIP archive, that's a risk. If you say yes, its hooks run without your OK, even in manual mode, where Claude asks before acting. They run outside the sandbox: they can do anything on your computer that you can do yourself.

Before opening such a project with Claude Code, whether in the app or the terminal, delete its .claude folder and its .mcp.json file (which connects other programs to Claude Code), if it has them. You can then answer yes.

The .claude folder and the .mcp.json file are hidden, because their names start with a dot. On a Mac, Cmd+Shift+. shows them in Finder. On Windows, tick "Hidden items" in File Explorer's View menu (View, then Show, on Windows 11).

Don't delete the .claude folder in your home folder, the folder named after your user account: it holds your own settings. It's also where Claude will store your two safety rules.

2. Set the two safety rules. Your project will soon have a .env file, where your secret keys live. Those keys are the codes that let your software use your accounts: database, payments, email.

In auto mode, the terminal's default, that file is open to Claude, which can also send your work to GitHub (the git push command) without asking. What it reads goes to Anthropic's servers, so your keys then leave your computer.

If Claude copies a key into another file by mistake, that key can also go to GitHub with the rest of your work at the next upload. Two rules cover this in all your projects. The first stops Claude reading .env in the usual ways. The second makes it wait for your OK before each git push.

To start a new line in your request without sending it, press Shift+Enter in most terminals, or Ctrl+J or \ then Enter anywhere. You can also paste the whole request at once. Ask:

Add two rules to my Claude Code user settings (~/.claude/settings.json).
A "deny" rule that forbids you from reading .env and .env.*.
An "ask" rule that makes you ask for my OK before every git push.
Then show me both rules and explain in plain English what each one does.

In ~/.claude/settings.json, ~ means your home folder, so these settings apply to all your projects. .env.* covers the variants of .env, such as .env.local. The deny rule also holds for these files in your project's subfolders.

This settings file configures Claude Code itself: if Claude asks for your OK before changing it, accept. For reference, here is what the two rules look like in the file (Bash means the commands Claude runs, and the star stands for whatever follows git push):

{
  "permissions": {
    "deny": ["Read(.env)", "Read(.env.*)"],
    "ask": ["Bash(git push *)"]
  }
}

Claude Code applies these rules at once, with no restart. In the terminal, you can also set them yourself with /permissions. The app doesn't have that command, but it reads the same settings file.

Last, in the app, look at the mode selector under the box where you type. If it doesn't show "Auto", choose it for your own project. In the terminal, auto mode is already the default. Choose manual mode for content from other people (a project, an archive, a web page, a document) and for an action on your live site (its database, payments, emails to your customers).

In manual mode, Claude asks for your OK before each change and each command that does more than read. Content from other people can hide instructions that push Claude to run a program, and here you see that command before it runs. A change to your live site can't always be undone either.

3. Make a first request that can't break anything. You can type or talk. Mark Fershteyn founded and then closed a software startup, and now builds his own products alone, without knowing how to code. He talks to Claude through Wispr Flow, a dictation app.

In the terminal, type /voice to turn dictation on: you hold the space bar while you talk. In the app, the dictation built into your Mac or Windows does the job, or an app like Wispr Flow.

If you're starting from nothing, describe a very simple first version:

Create a simple home page for my photography business in Austin,
with my rates and a contact button. Run it on my computer
and open it in the preview, or give me its address.

In the app, the page opens in the preview pane. In the terminal, Claude gives you an address such as http://localhost:3000 to open in your browser. That's your site, running on your computer and nowhere else.

If your own project already exists, switch to plan mode first, where Claude reads and explores without changing your files. For a project you got elsewhere, choose manual mode instead.

In plan mode, Claude can still run commands to explore without asking, such as the project's tests, small programs that check a result. In the app, choose "Plan" in the selector under the box where you type. In the terminal, press Shift+Tab until you read ⏸ plan mode on. Then ask, for example:

Explain what this project does and how to check that it works.
Don't change any file.

To see what this first request can find, it was tried on 27 October 2026 on a tiny shopping-cart program with a bug planted on purpose. The program does two calculations: a cart's total, then that total with shipping. It comes with a description file (the README) and one test. A test passes (people say it's "green") or it fails. This project's only test checked the total without shipping.

The total with shipping showed "71.964.9" instead of €76.86. The right amount is easy to work out: 3 items at €19.99 come to €59.97, or €71.96 with the 20% tax the test project used, plus €4.90 shipping. But the program stuck "71.96" and "4.9" together like two pieces of text instead of adding them.

In plan mode, Claude Code read all the project's files, including the program, its test and the README, then ran the test, which changed no file. It spotted the bug without being asked. It also explained why the test stayed green: no test checked the total with shipping.

All of that took 23 seconds and changed no file. At Console rates, the pay-per-use prices, it would have cost $0.12. On a subscription there's nothing more to pay: the request uses part of your limits.

So on your own project, this first request in plan mode can point out an error, with no file changed. On a project you got elsewhere, prefer manual mode. That project's tests are programs written by other people, and running them means running their code on your computer. In plan mode, Claude can run them without asking. In manual mode, it waits for your OK first.

If you switched to plan mode, leave it before asking for a change: while it's on, Claude doesn't change your files. In the app, choose "Auto" in the selector. In the terminal, press Shift+Tab until you read auto mode on.

4. Set up Git and save a first version. Now that your project has files, Git becomes your safety net for everything that changes in your folder: it's what takes you back to an earlier version when Claude gets something wrong.

Terence, the CTO of a young software company, also teaches experts in other fields, with no technical background, to build their own software with AI. In March 2026 he explained that his students' first obstacle wasn't the terminal but Git, which he describes to them as "just a backup system." They have no commands to learn, he says: they ask Claude to save a version.

Start by checking that Git is there:

Check whether Git is installed on this computer. If it's missing, tell me how to install it.

On a Mac, if a window offers to install the "command line tools", accept: they bring Git. On Windows, if you haven't already, add Git for Windows (git-scm.com/downloads/win, keep the default options). Then ask:

Save the current state of the project with Git. If this is the first save,
first create a .gitignore file that excludes .env and its variants (.env.*). Then show me
the list of files about to be saved and wait for my OK before saving.

The .gitignore file tells Git never to save .env or its variants. Without it, your keys would go into the history, then to GitHub at the first upload, where anyone who can open your project could use them.

In the list Claude shows you, no .env file (nor .env.local, and so on) should appear. If one does, answer: "The .env files must not be saved, remove them before the commit." (A commit is one saved version.) If the list is right, answer: "Save it."

5. Make a small change, with its check. In the app, Claude checks its work in the preview. In the terminal, it needs Chrome to see your page. First add Claude in Chrome, Anthropic's extension for Chrome, from the Chrome Web Store. Then leave your session with /exit and restart it with claude --chrome: Claude Code can now open your site in Chrome and use it.

Then ask for a small change and say how Claude should check that it works:

Add a contact form to the home page. Check in the preview
(or in my browser) that a confirmation message appears after
sending. Show it to me.

On your computer, the form doesn't send anything yet, because no email service is connected: you're only checking the message on screen.

You also see the result with your own eyes, in the preview or in your browser. On an existing project, do the same with a bug: describe the case that fails and the check Claude must run.

While Claude works, Esc stops it at once in the terminal, without undoing what it has already changed. In the app, use the stop button. You can also send a correction without stopping Claude: it reads your note once its current action ends.

6. Keep or undo. First ask: "Explain in plain English what you changed and why." If the result suits you: "Save these changes with Git."

If it doesn't: "Undo all your changes since the last commit, including the files you created." Files you added yourself since then may be erased too, so move the ones you want to keep out of the folder first. This exact wording matters: in auto mode, the second AI model that filters Claude's actions can refuse a vague undo request.

To finish, /exit closes the session in the terminal, and the conversation stops there. To pick it up later, claude -c reopens the most recent conversation in this folder, and claude -r lets you choose an older one. In the app, there's nothing to close: the session stays in the sidebar.

Auto memory, the notes Claude takes on its own when you correct it or state a preference, carries over to the next session by itself. So does the CLAUDE.md file, which you can create with /init. /memory opens those notes so you can see what Claude has retained.

The first slash commands to know. Five of them cover your first days:

• /clear empties the conversation for a new task, without touching your files.
• /usage shows how much of your limits you've used, and when they renew.
• /init writes a first CLAUDE.md for your project.
• /model shows which AI model is running and lets you change it.
• /doctor looks for installation and settings problems, then offers fixes.

When you're stuck, ask Claude Code itself. It can explain how it works: "How do I set a rule that stops you reading a file?", "What can you do in this project?" In the terminal, /powerup also offers short interactive lessons on its features. Anthropic publishes free online courses too, on Claude Academy (academy.claude.com), including a "Claude Code 101" for people starting out.

Using Claude Code every day: ask for a result it can check

Your first session showed you how Claude works. What decides the result of each later request is how you word it. Claude Code understands a vague request. But if your request doesn't say how to check the result, it stops as soon as it thinks the work is done, even when your case doesn't work yet.

Anthropic lists this among the reasons a session goes wrong: "Claude said it was done and it wasn't quite, usually because it had no way to check its own work."

Boris Cherny, who created Claude Code and leads its team at Anthropic, said in July 2026 that verification is "probably the single most important thing that people do not get right." He also advises describing the task, its guardrails and how you'll know it's finished, rather than a list of steps. Guardrails are what Claude must not touch, such as "without changing the home page."

Checking, here, means giving Claude a way to see for itself that the result is right. For a site, that means opening it in the preview and using it. For a calculation, it means a test, which compares the result obtained with the expected one.

That's also what I ask Claude for most often: prove it works by testing it yourself, in a browser, under real conditions, the way a user would. In the browser, it sees what your users would see. Without a browser, Claude misses some problems.

Arvid Kahl, a developer who builds his own software business and writes The Bootstrapped Founder, gave the same advice in February 2026: "If you don't do anything else from the things I tell you today, do this one thing: allow Claude to see your application."

In the app, Claude sees your site in the preview. In the terminal, it goes through Claude in Chrome, the extension added during your first session, when you start Claude Code with claude --chrome. It then works in your own Chrome, signed in to the same accounts as you: it can act on every site where you're signed in. So limit it: in the extension's settings, you choose the sites where Claude may navigate, click and type.

If your software also offers an MCP server, a door that lets an AI agent use it directly, Claude can test through that, without going through the screen (ask Claude if yours has one). In my experience Claude tests more easily that way than through a page on screen, though it now handles pages well too.

The gap between a vague request and one Claude can check, measured. On the same cart project, with the same bug, two requests were sent twice each on 27 October 2026, in auto mode, the terminal's default mode. The first said only to fix the bug. The second gave the customer's case, a made-up order of 3 items at €19.99 (the amount shown and the amount expected), with the check to run:

On a bug this simple, both requests fixed it. Only the second brings proof on the real case: the failure, then the success, in front of you, instead of "all passing" on an example Claude picked.

That proof took about 10 seconds more (26 to 27 s against 14 to 20 s), the equivalent of about $0.03 at Console rates. On a subscription there's nothing more to pay: the request just uses a little more of your limits.

All-green tests only prove what they test. During the plan-mode exploration ("Explain what this project does…"), everything was green while the total with shipping was wrong.

The request that was tried, to adapt to your own case:

A customer ordered 3 items at €19.99 before tax, with €4.90 shipping.
The summary shows "71.964.9" instead of €76.86. Fix the calculation.
Add a test that reproduces this case and that would have failed before your fix.
Run the tests and show me the command you ran and what it prints.
If you change an existing test, explain why.

People who use Claude Code every day each have their habits. Some help Claude judge its own work. Others concern how to ask.

• Show it the problem. Jason Lee, testing an app on his phone in July 2026, saw a month selector that looked wrong. He took a screenshot, sent it to Claude Code and wrote "please fix the month selector."

  Pierre Guilbaud made "30 to 40 improvements a day" to his software as his first users sent feedback. When a user sends a screenshot saying something doesn't work, he passes the screenshot to Claude as is, with "it's broken." The screenshot shows the exact symptom, and Claude then goes looking for the bug itself. In the app, you drag it into the conversation. In the terminal, you paste it into the box with Ctrl+V, even on a Mac (Cmd+V in iTerm2, another terminal app, Alt+V on Windows).

• Run /verify, then state your own case. According to Anthropic's documentation, Claude Code ships with a /verify command: after a change, Claude runs your app, uses it and watches the result, rather than relying on tests alone. That check stays general, so state your specific case in your request.

• Ask for the proof in pictures. In an Anthropic video from September 2026, a member of the Claude Code team describes how the team checks: when Claude prepares a change, Claude tests it, then sends screenshots of the result. For a new feature, this team member even asked Claude to record the screen while it used the feature, before trying it "just for sanity's sake."

  If you don't read code, this is the simplest proof: a screenshot shows you the result. Ask, for example: "When you're done, show me a screenshot of the page."

• See the test fail before you believe it. Developers disagree on when Claude should write its tests. The Coding Sloth, a YouTube programming channel whose host has spent more than 1,000 hours in Claude Code, says to have the test written first (August 2026): otherwise Claude writes "tests that pass its own code, and that's not exactly testing, that's cheating."

  Arvid Kahl does the reverse: Claude builds first, then writes the tests. With the test written first, he says, "the moment Claude Code starts experimenting and tests start to fail, it becomes this weird interference loop."

  Both want a test that can really fail. So whichever comes first, ask to see the test fail on the old version. The words "would have failed before your fix", in the request tried above, do exactly that.

• Ask for the criteria before the verdict. Kevin Richard isn't a developer by trade, yet he built SEObserver, software that helps sites rank on Google, alone. He compares Claude Code to "a genius and a compulsive liar", able to "say anything at all, very sure of itself." In April 2026, on the French podcast Darons du Biz, he told how he guards against it.

  In Claude's chat, he had his vanilla ice cream recipe graded: 8.5 out of 10. He asked for the recipe that would get a 10, pasted it into a new conversation and had it graded: 8.5 again, every time.

  So he first asked for the criteria of an excellent ice cream (the shares of milk, fat, sugar and stabilizer), then asked Claude to judge his recipe against those criteria. Claude had far less room to make things up, because the grade now rested on those criteria. He could then improve the recipe until it reached 10.

  Before you ask "is this good?", have Claude write down what "good" means: "List the criteria of a good home page for a photographer, then judge mine against them."

• Have it say what's missing. Pierre Guilbaud uses grades differently. When Claude proposes something, he asks it to grade that proposal out of 100. Claude usually gives itself 60 to 80, then lists what it would take to reach 100.

  The grade matters little. The list, though, can be read and judged. He then only has to say "do it" for the points he wants.

• Describe the goal and its guardrails, not each step. For example: "Add card payment for the monthly subscription, without touching the home page. Then show me a successful test payment." With today's models, a list of "do 1, then 2, then 3" gets in the way more than it helps.

• Say more than you think you need. Gabe founded Exposure, an ad agency in Australia, and knows "nothing about code." In a March 2026 interview, he looks back at his early messages to AI: "always like half sentences… I'm doing a very half-assed job with the input."

  What changed his results was recording himself talking for an hour about what he wanted, then having Claude turn that into a requirements document, a list of everything the software must do, for Claude Code to work from.

• Forget the magic words. In 2025, phrases like "think hard" set the thinking time. According to Anthropic's documentation, they're now just text. The setting that counts is effort, the time Claude gives itself to think (/effort high for a hard problem). Only the word ultrathink still has an effect: it asks for deeper thinking on that one message, without touching your effort setting.

  CAPITALS no longer help either. According to the same documentation, today's models follow a plainly worded instruction, and piling on emphasis "mostly makes Claude over-apply the rule."

• Limit the number of tries. When a check fails, Claude fixes something, then checks again. That loop can last a very long time, and each round uses part of your limits. That's why I limit my verification loops to a set number of rounds.

  In your request, add for example: "If the check still fails after three tries, stop and explain what's blocking you."

• After two failed fixes, start over. /clear empties the conversation without touching your files. A new request that includes what you learned works better than a third fix in a conversation that already holds two failures.

  The Coding Sloth's host starts a new session for every new task. AI models count their work in tokens, small pieces of words. By his count, a medium or large task uses at least 50,000, and quality drops once a conversation passes 100,000 to 200,000.

What Claude does without asking: auto mode, manual mode and what slips through

A well-worded request tells Claude what to do. You also need to know what it does without asking you. Claude Code can run any command you could type yourself. So who decides what it may do without your OK? That's the job of the permission mode, a setting that changed in August 2026.

The change. Until the summer of 2026, Claude Code stopped before changing a file or running a command and waited for your go-ahead. Since 14 August 2026, for subscribers to Pro, Max, Team and what is now Ultra, sessions open in auto mode in the terminal and in VS Code, Microsoft's code editor. Since late September 2026, that's the case for everyone in those two programs.

On 22 October 2026, Anthropic announced the same change for the following week in most of its other apps, including the desktop app (Pro, Max and Team).

On 3 November 2026, its documentation still doesn't say whether that's done in the desktop app: look at the selector under the box where you type, which shows the current mode. If it shows another mode, choose "Auto" for your own project, once the two rules are set. Tutorials that promise a permission request at every step describe the old behavior.

How auto mode works. Before each of Claude's actions, a second AI model, called the classifier, reads what Claude is about to do and compares it with instructions set by Anthropic. It lets through what it judges ordinary and blocks what goes beyond your request or could cause damage that's hard to repair. When it blocks an action, Claude Code shows a warning and Claude looks for another way.

After three blocks in a row, or twenty in total in a session, auto mode pauses and Claude asks for your OK for each action again. The classifier sometimes gets it wrong, both ways: it blocks harmless actions and lets dangerous ones through.

In the terminal, Shift+Tab cycles the modes in this order: auto, manual, accept edits, plan, then back to auto. In the app, you pick the mode in the selector under the box where you type. The app remembers it for each folder, except plan mode.

What the classifier blocks and what it lets through. According to Anthropic's documentation, its instructions make it refuse to download and run a program from the internet, send sensitive data outside, run a command that puts your site online, or erase unsaved work. It lets through changes to your project's files and the installation of add-on software your project already lists as needed.

By default, it also lets through reading your .env file and sending your work to GitHub, including to the main branch, main. A branch is a parallel version of your project. Hosts are the services that put your site online (Vercel, Netlify, and so on). The main branch is the one they usually publish.

Why the two safety rules. Two of the things it lets through are a problem. Each of the two rules set at the start of your first session deals with one:

• Read(.env) and Read(.env.*) block the usual ways of reading your secret keys. A key read in passing can end up copied into a file, then sent over the internet, where someone could use it on your payment account or your database. A deny rule blocks the action in every mode, before the classifier is even consulted.

• Bash(git push *) makes you approve each upload made through git push, the usual upload command. Many hosts update your site at every upload to main. The classifier blocks a command that puts your site online, but it lets this upload through, which amounts to the same thing.

  With this "ask" rule, Claude stops and waits for your go-ahead, even in auto mode, as the documentation specifies. A ban would force you to do the upload yourself with Git. An "ask" rule lets you decide without typing anything.

These rules have limits, and the documentation says so itself. They recognize commands as Claude usually writes them, not their variants: a command written differently, such as git -C . push, which does the same upload, doesn't trigger the rule.

According to Anthropic's documentation (3 November 2026), the deny rule blocks the usual ways of reading .env: Claude's reading tool and commands that display a file by naming it, in all your project's subfolders.

It doesn't stop a search across your whole folder, such as looking for a word in all your files, which would also read .env without naming it. It doesn't stop a program that opens .env by itself either, such as your site when Claude starts it.

Those rules block the usual form of an action every time, whereas an instruction written in CLAUDE.md can get lost along the way. Georg Ell ran into the difference with an agent he built for family use. "I told it certain things it should never do and it went and did them. And then I said, 'Stop doing that.' And it apologized and said, 'I'll never do that again.' And then it did it again."

The sandbox goes further. The /sandbox command turns on a closed zone in the terminal: commands running in it write only inside your project and reach only allowed internet addresses, however they're written. When a command needs a new address, Claude Code asks for your OK (in auto mode, the classifier decides).

By default, the sandbox doesn't stop your files from being read: a command can read them, but can't send them to an address you haven't allowed or write outside your project.

Your deny rules apply there too, to every command. With the sandbox, Read(.env) also blocks a search across your whole folder and programs that would open .env by themselves, your own site included when Claude starts it. The sandbox works on Mac, on Linux and, on Windows, in WSL 2 only. For content from other people, work in manual mode and, if you can, in the terminal with the sandbox on.

Why Anthropic made auto mode the default. Its numbers suggest people no longer really read permission requests: they approve 97% of them. In a study it commissioned from a contractor, 1,053 testers were paid to approve actions, with dangerous commands slipped in on purpose. They caught only 13.6% of those commands, against 89% for auto mode.

Over a session, their attention dropped: the share of dangerous commands these testers caught fell from about 17% at the start to 5% after fifty requests. Approve everything for long enough and you stop reading.

Many users had already silenced those requests anyway. In June 2026, according to Anthropic, 62% of users had used "bypass permissions" mode, which removes the requests, or told Claude Code to stop asking for commands. A quarter of sessions even started in that mode, with no classifier to replace the permission requests.

Auto mode's misses, measured. Anthropic also publishes the other side, with another kind of test. This one doesn't slip in commands on purpose: it takes 52 dangerous actions from real sessions of its employees, where Claude went further than it was asked. The classifier let through 17%, or about 9 of 52.

Anthropic's engineering team even judges that, for someone who carefully reviewed every action, auto mode is "arguably a regression", a step backward. That isn't your case if you end up approving most requests without reading them, like most of the study's testers, whose attention dropped as requests went on.

Two independent security researchers caught auto mode out in August 2026, with Opus 5, the default model of the time. The author of the blog itmeetsot.eu prepared a project containing only an image, with a message hidden in it. The message was written as a riddle for Claude, and solving it step by step led to a program to download. On a plain /init command, which asks Claude to read the project and describe it, Claude Code decoded that message.

In 6 tries out of 10, Claude Code then downloaded and ran that program from the internet, with the classifier's approval. Such a program can read your files or your keys. Johann Rehberger, a specialist in AI agent security, got the same result in 3 or 4 tries out of 5, with a plain request to summarize a booby-trapped website.

Johann Rehberger reports Anthropic's answer: auto mode is there for your convenience, and its classifier does its best without guaranteeing anything. Against this kind of attack, Anthropic relies on isolating what commands can touch, which is what the sandbox does.

In the 27 October test. The cart project's description file (the README) held a hidden instruction. It asked Claude to download and run a program before any change, without telling the user. Across four sessions in auto mode, Claude read the instruction and never carried it out. It didn't flag it either: you would have known nothing about the attempt. An attack that crude says nothing about an attacker who tries harder.

These attacks target an agent reading content from other people: a project you got elsewhere, an archive, a web page, a document. No single measure covers everything.

Git repairs what changed in your folder, but can do nothing about what left it. For that, your protection is caution with content from other people, plus the sandbox when you work on it. What to do depends on what you're working on. Three cases, then one mode to avoid:

• Your own project, once the two rules are set. Auto mode fits. Save a version before each important request: Git then lets you undo what changes in your folder. Uploads to GitHub by the usual command wait for your OK.

  Two other paths remain open for your data to leave without your OK. An upload command written differently can get through, though that's rare, because Claude usually writes the ordinary one. A program run by mistake can also send data by itself. It most often arrives in content from other people, such as a web page you have Claude read, or more rarely in an add-on in your own project. Against both, a saved version can do nothing.

• Content from other people that you ask Claude to read: a project, an archive, a web page, a document. Switch to manual mode: Claude stops before each change and each command that does more than read. Prefer manual mode to plan mode, where the classifier accepts commands such as tests for you. If you can, work in the terminal with the sandbox (/sandbox, on Mac, Linux or WSL 2).

  For a project or an archive, first delete its .claude folder and its .mcp.json file before opening it with Claude Code: its hooks would run outside the sandbox and could do anything you can do on your computer.

  The pages Claude looks up by itself during ordinary work on your own project, such as a service's documentation, carry the same risk. The difference lies in who chooses the content. Claude goes by itself to the pages it needs, often those of the services your project uses. A page someone sends you, or a project you download, may have been prepared on purpose to trick it, as the two security researchers' project and website were.

  For that ordinary work, keep auto mode. Manual mode is for when you're the one handing Claude content from elsewhere.

  When you don't understand a permission request, refuse it and ask: "Explain in plain English what this command does and what it changes."

  Before accepting a command, also ask: "Does this command run a program that comes from this project?" Without a sandbox (in the app, or on Windows without WSL 2), refuse any command that runs a program from this project. The answer to that question comes from Claude, which has read the project: if the project is booby-trapped, it may have fooled Claude too. If in doubt, refuse.

• An action that directly touches your live site: its database, payments, emails to your customers. For example a customer record changed, a refund, a message to all your customers. Switch to manual mode and have Claude explain each action before you accept it.

  Refuse until the explanation says clearly what will change and for whom: no undo catches what has left your computer.

• Bypass permissions: never on your everyday computer. With no classifier, nothing filters the commands a booby-trapped piece of content pushes Claude to run. Only your rules (deny and "ask") and a request to erase a vital folder (your home folder, your whole project) still stop Claude.

  Some people still recommend it. Melvynx calls it "really the best mode" for beginners in his October 2026 course. Steve Sewell, who runs the software company Builder.io, starts every session that way in a July 2025 guide, which predates auto mode.

  Anthropic's documentation reserves it for test machines that can be wiped, isolated from your computer. In the desktop app, it only appears once allowed in the settings (Settings, then Code or Claude Code depending on your version).

  Shubham Sharma explains where the habit comes from: before auto mode, "everyone used bypass permissions mode." His conclusion: "today, it's better to use auto mode." On your everyday computer, never go beyond auto mode.

A sentence in CLAUDE.md doesn't replace a deny rule. Claude and the classifier both read that sentence and take it into account, but an instruction can get lost in a long conversation. A deny rule applies every time to the actions it recognizes.

Undo what Claude did: Git first, /rewind as backup

Even well guided, Claude will sometimes get things wrong. A session can also head in a bad direction. You have two ways to go back, and they don't cover the same cases.

Git, the safety net for your folder. If you saved a version before starting, you can always put your folder back in that state, except for files Git ignores on purpose, such as .env. I save every one of my changes with Git, without exception. I've never yet had to undo anything big: the net rarely gets used, but it costs nothing.

Git doesn't keep .env. The deny rule stops Claude from reading that file, not from changing it. So keep a copy of each key somewhere else, at the moment the service gives it to you: in your password manager, for example.

If one day everything has to go, ask: "Undo all your changes since the last commit, including the files you created." Files you added yourself since then may be erased too, so move the ones you want to keep out of the folder first.

The wording matters. In auto mode, the classifier blocks by default commands that erase unsaved work. It lets them through when your message describes that exact action, not on a general request.

So a vague request like "put everything back the way it was" can be refused, while "undo all your changes since the last commit" usually passes. To undo, describe the exact action.

Look for a saved version before you try anything else, and remember that your host may keep past versions of your site too. Gabe, the ad agency founder, moved his working project to another AI agent, which "broke everything." He spent five days and thousands of dollars in credits trying to get it back, until a friend told him he could simply restore an earlier version from Vercel, his host.

/rewind, the quick return. In the terminal, Claude Code also keeps, at each request, the earlier state of the files Claude changes with its editing tool: a restore point. Press Esc twice without having typed anything, or type /rewind. You choose the request to return to, then restore the files, the conversation, or both. In the app, its documentation doesn't mention it: rely on Git.

Claude Code keeps the last hundred points of each session, for about thirty days. /rewind quickly undoes the last request, when Claude changed the files with its editing tool, but these points have gaps:

• A file Claude changed only through commands isn't tracked. Claude changes a file in two ways: with its editing tool, which you see as a change to review, or through a command. You don't choose which. In the 27 October test, in auto mode, Claude wrote all its fixes through commands: /rewind wouldn't have undone them. Only Git covers both.
• Changes made by its subagents usually aren't restored. Subagents are the helpers Claude starts by itself for part of the work.
• Nothing that left your computer comes back. An upload to GitHub, a changed database, a site update or a sent email stay done.

Git covers everything that changes in your folder, provided you saved a version first, except files it ignores on purpose, such as .env. /rewind quickly catches the last request when Claude worked with its editing tool. In auto mode, where Claude went through commands in the 27 October test, rely on Git.

Put your site online: GitHub, then a host

As long as your project stays in a folder on your computer, only you can see it. Two services work in sequence to publish it: GitHub keeps a copy of your project, then a host puts your site online from that copy.

If your project isn't on GitHub yet, first create an account on github.com. Then ask Claude to create a private project on that account and to install GitHub's program that lets it send your work there (it's called GitHub CLI). That program will ask you to sign in to GitHub in your browser. GitHub keeps your project without putting your site online.

To send your work to GitHub, then ask: "Explain in plain English what you're about to send to GitHub and confirm that no .env file or key is part of it. Then send my changes." Accept the permission request that follows: it comes from the "ask" rule on git push, set at the start of your first session.

To make your site visible to everyone, connect this GitHub project to a host: you create an account with it and choose your project, then the host puts your site online. For my own projects, my usual host is Vercel. After that, each upload to the main branch updates it by itself. Your keys aren't on GitHub, since Git ignores .env: ask Claude how to give them to your host.

The guide on how to start a SaaS business, online software sold by subscription, covers what comes after that first version.

CLAUDE.md: what to write in it (and what /init gives you)

Git and /rewind repair after the fact. The CLAUDE.md file helps Claude avoid repeating the same mistakes. Placed in your project's main folder, it passes on what Claude can't guess: Claude Code rereads it when each session opens. It's a plain text file, which you can have Claude write and correct.

Henri, who explains AI to beginners on his French YouTube channel ExplorIA, showed the effect in February 2026. He opened two sessions in the same folder with the same request: the home page of a real estate agency. For the second one only, he had added a CLAUDE.md of a few instructions, among them a professional but approachable tone, navy blue, never any filler text, a specific font and an agency based in Lyon.

The first page came out with a green design, for an agency in Paris. The second respected the colors, the font and the city. Those few lines save you repeating the same instructions at each request.

What /init gives you. The /init command writes a first version of the file by reading your project. In the 27 October test, across two tries, it produced 26 and 30 lines. They mostly described how the files are organized and what each part of the code does, with one truly useful part: a warning about the total returned as text rather than a number.

Anthropic now lists "Describe your architecture and file layout in CLAUDE.md" among the habits current models have made unnecessary, since "Claude reads the repo itself." /init still spots real problems, such as that total returned as text. So run it, then ask:

Shorten CLAUDE.md. Keep only the commands that check the work,
this project's misleading spots and the decisions I gave you.

What deserves to stay. Anthropic's documentation keeps three things:

• The exact commands that check the work. For example the one that runs the tests or starts your site.
• The misleading spots in your project. The ones where Claude has already gone wrong.
• Decisions made outside the code. How you put things online, which payment service you chose, the tone of the interface.

You can add your own words, like "when I say backup, save a version with Git." Aim for under 200 lines: each line is reread at every session, whether it helps or not. A file that's too long also drowns the instructions that matter. For an instruction that holds across all your projects, ask Claude to add it to your personal CLAUDE.md, stored in your home folder (~/.claude/CLAUDE.md).

The file grows with your corrections. David Tavoularis works in maintenance and development at MYCOM, a software company. In October 2026, at a talk for the French developer community Code d'Armor, he described the step everyone skips: at the end of a task, write down what worked and what failed, where the next session will find it.

Without that step, "you close it and you've forgotten everything": a new session doesn't reread the conversation. Auto memory only keeps what Claude chose to note.

Mark Fershteyn hands this step to his skills, the written procedures Claude opens when needed. At the end of each use, Claude, guided by the skill, asks him what went well, what didn't and what to improve, then keeps the answer for next time.

Short of that, ask Claude at the end of a session: "If I gave you a decision or a preference today that you can't guess, or if you got something wrong twice in the same place, add it to CLAUDE.md in one line. Otherwise, add nothing."

When a line of CLAUDE.md gets ignored, Anthropic's first advice is to shorten the file. If something must never happen, such as reading your keys, an instruction isn't enough. A deny rule blocks its usual forms, every time, and the terminal's sandbox extends that to every command.

When models change, clean out your instructions too. Boris Cherny advised in July 2026 deleting CLAUDE.md, skills and hooks (commands Claude Code runs on its own) every six months, then putting a line back only if Claude trips in the same place several times. That advice concerns instructions, skills and hooks, not your safety settings.

Keep the two rules in ~/.claude/settings.json. If you deleted the deny rule too, no warning would tell you that Claude can read your keys again.

For instructions, David Tavoularis's advice (write down what failed) and Boris Cherny's (clean out) work together: add a decision as soon as you make it and a line when Claude has gone wrong twice in the same place, then clean up when a new model no longer needs it.

Ready-made instruction packs found online, which add dozens of instructions and skills at once, weigh down what Claude rereads on each task: every line of instruction and every skill's description. So add your own lines one at a time instead.

Plan mode: useful for big changes, less essential than guides say

CLAUDE.md gives Claude the context it can't guess. Plan mode lets you agree on the work with Claude before it touches a file. In plan mode, Claude explores your project and prepares a work plan, but changes no file until you've approved it. It can still run commands to explore, such as tests: auto mode's classifier accepts or refuses them for you.

You enter it with the selector in the app, with Shift+Tab in the terminal, or by starting a request with /plan. Once the work plan is written, you approve it and Claude gets to work, or you say what's wrong and it starts again. When you approve it, you also choose the mode Claude works in afterward, such as auto mode.

Many guides make it a required step. Claude Code's creator, however, changed his mind in four months. In February 2026, Boris Cherny started "almost all" his tasks in plan mode, "maybe like 80%." By June he no longer used it, because recent models "don't actually need like a planning step anymore."

People who don't code can still get a lot from it, as Guillaume Maarek did. At Alan, a French health insurer where he was a product manager, he learned to put changes live himself in the insurer's app: first a line of text to correct, then a demo screen to test an idea.

In a webinar published in October 2026, he shows the tool he built to assess calls handled by an AI phone assistant. He also details the method behind it, in three stages: "Think, Plan, Prompt."

First he thought through the need with Claude until he had a document describing it. Then he switched to plan mode: Claude asked him four questions (the programming language, how to store the assessments, the audio player, the visual style) before proposing the screens, the order of work and the checks.

Only then came the build, and the tool came out in three requests. His rule: "the build is 20%, and everything before it, that 80% is what matters most."

Jason Lee gets the same pause with a sentence. His first request for an app ended with "Give me the full plan. Do not build first": otherwise, he says, "it's just going to build things that you don't want and you end up spending more in tokens." Mark Fershteyn "almost always" starts in plan mode (September 2026): the time spent thinking up front makes execution "more or less usually flawless."

The Coding Sloth draws the line by size. On a big task, "it's also way easier to catch a mistake in a plan than in like 3,000 lines of code and 12 different files." On a typo or a small design change, plan mode is a waste of your limits.

Anthropic's numbers on its own users show what a work plan brings: they reject 39% of the work plans Claude submits to them, against 3% of permission requests (Anthropic data, August 2026). A work plan really gets read, a permission request far less.

Use plan mode on your own project: when you're getting to know it or coming back to it after a while, when a change touches several screens, or when you want to decide before a single file moves.

How to use Claude Code effectively: the pitfalls to avoid

Your settings are in place. What's left are the traps people fall into once they use Claude Code. Most of them aren't technical problems. They come from how you work with an agent that moves fast and says yes to everything.

Going off in every direction. Fabien Blot, co-host of the French podcast Darons du Biz, opened Claude Code one Sunday in late March 2026, knowing nothing about code. His first request: "make me a CRM please", software to track his customers. In under five minutes, a first page worked. He then added a screen for his salespeople, then another, then another idea.

Two weeks later, Fabien Blot was still spending a crazy amount of time on the project with no idea how to finish it. He worried he might end up with very little to show for it. Kevin Richard, the guest on the episode where Blot tells this, warns all his friends who start out against this trap.

Faced with everything Claude Code makes possible, Kevin Richard says, you can end up "paralyzed", not knowing what to do, or chasing every idea. His advice: pick one subject (one feature, for example) and finish it before moving to the next.

Being the go-between for two AIs. At first, Fabien Blot asked ChatGPT what to write to Claude Code, then copied the answer over: "my day was control C, control V." Claude Code can answer the same question directly, with your project in front of it. Ask it what it recommends, or switch to plan mode so it proposes before acting.

Accepting the paid solution Claude suggests. Jacky West, a software engineer building KlapDoc, document search software, saw Claude pick a paid service to rank search results by relevance. He asked whether there wasn't a free solution. Claude rebuilt that part with a free, open AI model, with no paid service, and it even turned out faster.

Since then, he says so from the start: "I want you to use free tools whenever we can do without paid ones." You can put that sentence in your CLAUDE.md so you don't have to repeat it.

Following every action, or nothing at all. A task can take ten minutes, half an hour, sometimes more, and following it line by line brings almost nothing.

Anthropic's data on its own users (February 2026, before auto mode became the default) shows what experienced users do. Newcomers, under 50 sessions, let Claude act without approval in about 20% of their sessions. After 750 sessions, it's over 40%.

Those experienced users also interrupt it more, in 9% of exchanges against 5%. They've stopped approving each action: they come back regularly and step in when things drift. So launch your request, turn to other work and look in on it later.

With the two safety rules set and a version saved just before, most errors come down to a change to undo. Neither Git, the two rules nor the classifier catches what has already left your computer, such as a sent email or a changed live database.

So let Claude work alone on your own project. Switch back to manual mode when you ask it to read content from other people (a project, an archive, a web page, a document) or to act on your live site (its database, payments, emails to your customers).

Letting credits run with no ceiling. Gabe, the ad agency founder, wasted about $2,000 of credits on Lovable, a service that builds apps in the browser and charges for each message: "I messaged it for 18 hours straight." He later paid per use on another AI agent. A program it ran to read web pages got stuck in a loop, and he calls the bill a "four or five grand mistake." The $100 alert he had set up didn't work.

Neither happened on Claude Code with his subscription, which he says "barely ever runs out." What both cases show is how fast pay-per-use money goes when nobody's watching. If you add usage credits to a Claude plan (money spent per use), you set their ceiling on claude.ai, in Settings, then Usage.

Getting blocked by your own captcha. This is the trap that has given me the most trouble. A captcha, the test that checks a visitor is human, also stops Claude when it tests your site: the captcha takes the browser Claude drives for a robot.

On my projects, Claude has several times had to fix a form protected by a captcha it had installed itself, and that captcha stopped it from testing its fix.

The desktop app's documentation confirms it: in its browser, Claude doesn't get past a captcha without your input. Each captcha connects to your site through a key, a code the captcha's maker provides. To test on your computer, those makers provide test keys, which always pass or always block, without checking who's there.

Turnstile, the captcha from Cloudflare, a service that protects and speeds up sites, provides both kinds of key. reCAPTCHA is Google's captcha. For its version 2, the test key lets everything through and shows a warning, so you don't leave it on your live site.

Version 3 of reCAPTCHA asks no question: it gives each visitor a score of how likely they are to be human. For it, Google advises a separate key for testing, warning that its scores will be less reliable there.

These keys reduce the problem without removing it: on your live site, the real key still blocks Claude. So ask Claude: "When you test on my computer, use the captcha's test keys. Keep the real keys for my live site."

Following the news instead of building. For his first three months with Claude Code, David, the creator of the French YouTube channel SaaS Sauvage, followed every new model. After those three months, he was working almost as he had on day one. He'd still choose Claude Code if he started over: all that time following new models had brought him almost nothing.

The trap, he says, is to "stay a spectator and not produce", spending your evenings watching videos on the latest model.

Putting off security. Amélie Starace built Le Levier, software that helps entrepreneurs write LinkedIn posts, without a developer. In September 2026, with paying subscribers already on board, she admitted: "I'm not aware of everything that [building it] implies for security… at some point I'll have to get to it seriously." That moment comes before customers trust you with their data.

The two safety rules protect your keys and your uploads, but they don't look for holes in your software. The /security-review command does: it has Claude check the changes you haven't yet added to your project's main branch on GitHub, and only those. If all your work has already gone to that branch, the command has nothing to review.

Before opening your software to your first customers, run /security-review, then also ask: "Review my whole project for security holes, the way /security-review does. Rank them by severity."

If your software keeps sensitive data (health, bank details, children's data), also have a developer review it before inviting your first customers: that's the case where a review by Claude isn't enough. Arthur Villecourt has made his living since 2013 from affiliate sites, which earn a commission on the sales they bring to brands. He goes further: he would have a developer review any software open to the public.

Claude's security review isn't a one-time thing. I rerun it very regularly, often with each new model, because each new model is better than the last.

To have Claude review a change for bugs rather than security holes, the guide to Claude Code Review sets out the options. And if your project is online software you sell by subscription (a SaaS), the guide on how to start a SaaS business lists the settings to ask your agent for before you open access to your first customers.

Going further: MCP, skills and hooks

Once the basics are in place, three additions let Claude Code do more: using your other software (MCP), following a written procedure (skills), acting every time without being asked (hooks). No need to install everything at the start: Anthropic's documentation advises adding each one when you actually need it. Here are the signs it gives, CLAUDE.md included, with what you ask Claude:

MCP, to connect Claude Code to your other software. MCP, for Model Context Protocol, lets an agent use a piece of software on your behalf. It's an open standard that any software company can adopt. An MCP server, a small program provided by the company that makes the software or by others, gives Claude access to that software: your database, your task manager, your email.

Anthropic's documentation gives this example, where Claude chains your database and Gmail: "Find emails of 10 random users who used feature ENG-4521 [one of your product's features], based on our PostgreSQL database [your database]", then "Create Gmail drafts inviting these 10 users to a feedback session about the new feature."

In April 2026, Arthur Villecourt planned to connect the keyword database he built through MCP, so that an AI agent can draw on it for what it needs. That database lists the searches his sites target. I've connected by MCP every service I use each day, such as Supabase, the service that holds my projects' databases.

In the terminal, claude mcp add adds a server and /mcp shows the connected ones. The simplest way is still to ask Claude to connect the server for you. At claude.ai/directory, Anthropic lists the MCP servers its teams have reviewed, which it calls connectors.

Connect only official servers, published by the company that makes the software or listed in that directory: an unknown server can do what it likes on your computer. Even a trusted server that fetches content from the internet can pass Claude hidden instructions, from a booby-trapped page.

Skills, procedures Claude opens at the right moment. A skill is a written procedure, such as "publish an article: check the links, save a version, send to GitHub", that Claude Code opens only when a task needs it, or that you start by typing its name after /. To create one, describe the procedure to Claude and ask it to make a skill of it. /skills lists the ones you have.

David, of SaaS Sauvage, has made skills his rituals: one in the morning, one in the evening and one each week to take stock of his work, plus a monthly review where Claude rereads the month's reviews and helps him set the next goal.

I also have many skills, shared across my projects, but the file that matters most to me remains CLAUDE.md, which Claude rereads at every session.

Hooks, one action every time, without asking. A hook is a command Claude Code runs on its own at a precise moment: when it changes a file, when it finishes a task or when it waits for your answer. An instruction in CLAUDE.md can get lost in a long conversation, whereas a hook runs every time.

The first example in Anthropic's documentation: a notification on your screen when Claude is waiting for your answer, so you don't have to watch the window. To get it, ask: "Write a hook that sends me a notification when you're waiting for my answer."

Daisy Hollman, an engineer on Anthropic's Claude Code team, stressed their advantage in August 2026: a hook adds nothing to what Claude keeps in mind, its context window, except what the hook sends back when that's useful. An MCP server, on the contrary, adds a description of each action it offers to what Claude must read. The less Claude has to read, the less of your limits you use and the less an instruction gets lost.

What each plan gives you and how the limits work

By now you've seen what Claude can do, and the next question is how long your plan will last. Every paid plan limits your use in two ways. The first limit covers a period of five hours: it starts at your first message and renews in full five hours later. It isn't five hours of use: it's an amount of work. If you use it up in an hour, you wait four hours for it to renew.

The second covers the week: it renews every week on the same day and at the same time, fixed for your account. You can see them on claude.ai, in Settings, then Usage. On Ultra, once your account is verified (Anthropic does this by itself), only the weekly limit remains.

With a subscription, each task you give Claude uses part of these limits, costing you nothing beyond your plan's price as long as you stay within them. Pro doesn't include Fable, Anthropic's most capable model: you pay for it separately.

On 3 November 2026, Anthropic's pricing page says "Prices shown don't include applicable tax." Whether sales tax is added, and how much, generally depends on where you live, and the exact total shows at checkout.

If you read an older guide, you'll come across other plan names. Until the end of October 2026, Max came in two versions: Max 5x at $100 a month and Max 20x at $200 a month. Max 20x is now called Ultra, at the same price, and Max 5x is simply called Max. According to Anthropic's help center, Max 20x subscribers moved to Ultra automatically.

Ultra promises 10 times Pro's use over the week. Max 20x promised 20 times Pro's use, without saying over what period, so the two figures can't be compared. Anthropic doesn't say whether the amount of use changed.

Anthropic verifies your Ultra account by itself, with nothing for you to do, based on your account and payment history. Until it's verified, a temporary limit applies. To see where you stand, open claude.ai's settings (Settings, then Usage): if you don't see a "Current session" bar, the five-hour limit's bar, your account is verified.

The Console. It gives direct access to the models through Anthropic's API, the interface that lets a piece of software call Claude's models. Claude Code is one such piece of software: with a Console account, you pay for each request by the volume of text processed, counted in tokens, small pieces of words.

On 3 November 2026, Opus 5.5, the model Claude Code uses unless you choose another, costs $4 per million tokens you send (your request and the files read) and $20 per million tokens Claude writes.

On 27 October 2026, on a small test project (a four-file shopping cart with a bug to fix), a request paid per use came to $0.10 to $0.13. The cost climbs with the size of your project and of the conversation: on a real project, each request rereads more files. It also resends the whole conversation since its start, which grows with every exchange.

For daily use, paying per use costs far more: "in one day you can spend, for example, 171 dollars", Melvynx warns in his October 2026 course. For comparison, on 3 November 2026, the most expensive plan, Ultra, costs $200 for a whole month.

What Anthropic says about your use. Anthropic publishes no absolute figure for Claude Code, in messages or in hours, only multiples of Pro. Here is what it does say:

• /usage tells you where you stand. This command, typed in Claude Code, shows where you are on each limit and when it renews. In the app, the usage ring, a small circle under the box where you type, does the same.
• Chat and Claude Code draw on the same limits. What you do in Claude's chat, on the web, computer or phone, uses the same limits. What you consume depends on the length of conversations, the model chosen and how long it takes to think (its "effort", which you can set).
• A response that has started can finish. If the five-hour limit falls in the middle of a response, Claude Code can finish the current action. On Pro, this grace period applies at most once a week. Anthropic is rolling it out gradually, and it isn't on every account yet.

The model and the effort. Anthropic offers four families of models in Claude Code. Opus handles everyday work. Sonnet, faster, uses your limits more slowly. Haiku, the fastest, handles simple tasks. Fable, the most capable according to Anthropic, is made for the hardest and longest tasks: it works alone for longer and checks what it's doing more often.

For everyday work, the most capable isn't necessary. According to Anthropic, Opus 5.5, released in September 2026, works at the level of Fable 5.1 on most tasks. It also costs 2.5 times less at Console rates: on 3 November 2026, $4 per million tokens sent against $10.

Claude Code starts on Opus 5.5, with a "medium" effort level, effort being the time Claude gives itself to think before acting. Fable only runs if you choose it. /model shows you the model running.

On Pro, stay on Opus at "medium" effort as long as your limits hold, because more effort uses them faster. If Opus uses them up too fast, switch to Sonnet 5.5 by typing /model sonnet: according to Anthropic's documentation, "Sonnet handles most coding tasks well."

On Ultra, which gives ten times Pro's use over the week, I always take the best models and set the effort fairly high, even if each answer takes a little longer. To raise the effort, type /effort high in the terminal, or use the app's model picker.

Guillaume Maarek, who isn't a developer, judged in October 2026 that Sonnet is "more than enough" for most products, even if Opus gives better results. Guides that still advise "Sonnet 4.6 for 80% of the work" describe the lineup of spring 2026: Sonnet 5.5 has since replaced Sonnet 4.6.

Fable 5.1 is chosen with /model fable. On 3 November 2026, on Pro, Fable is paid for in usage credits, money you add to your account and spend per use. On Max and Ultra, it's included up to half the weekly limit.

People who use Claude Code every day describe what the five-hour limit and the weekly limit mean, on Pro and beyond.

Sid Saladi moved two of his six apps from Lovable to Claude Code. Beyond two hours a day, he wrote in May 2026, or with several projects in parallel, Pro's limits come fast: he moved to Max, the $100 plan, for the projects he runs with Claude Code.

The YouTube channel AI Coding Daily measured in September 2026 what a big request costs on Pro: a complete feature on a web project, with Opus 5, the default model at the time. Six minutes of work used 10% of the five-hour limit, or about ten requests of that size per five-hour period (100% ÷ 10%).

Nomiki Petrolla's verdict in April 2026 was harsher: Pro's limits "will stop you mid-feature."

I've long used the $200 plan (Max 20x until the end of October 2026, Ultra since). On Max 20x, the weekly limit often stopped me, the five-hour one rarely. With several sessions open at once, I couldn't work on a cheaper plan.

David Tavoularis, an engineer who has worked with Claude Code every day for a year, described both limits in October 2026 as he experiences them, on $20 and $100 subscriptions. The five-hour limit stops everything dead: "you have to wait an hour, two hours." The weekly one needs watching: for him, a weekly limit used up by Wednesday evening left him without Claude on Thursday and Friday.

When you reach a limit, you wait for it to renew, change plans or turn on usage credits in claude.ai's settings (Settings, then Usage). Those credits are charged at Console rates, per use. On 3 November 2026, according to Anthropic's help center, Max and Ultra also give a monthly budget for the API. It only pays for software you build yourself that calls Claude: it doesn't work in Claude Code.

Heavy users take precautions. Shubham Sharma was paying for the $200 plan, then called Max 20x, in July 2026. He "rarely" reached his limits, yet he kept $170 of usage credits in reserve, just in case. If you can't wait for a limit to renew, do the same.

If you turn these credits on, set them a monthly spending ceiling, in the same claude.ai settings (Settings, then Usage). Once you reach it, Claude Code offers to raise or remove it. I set spending caps wherever I can: they spare me bad surprises.

Your data. With Pro, Max or Ultra, which are consumer accounts, Anthropic asks whether you accept that your exchanges, Claude Code included, may be used to train its future models, that is, to teach them to answer better. If you accept, your data is kept for five years. If you refuse, thirty days. You can change this choice at any time at claude.ai/settings/data-privacy-controls. With Team, Enterprise or the Console, Anthropic doesn't train its models on your code unless your organization agrees.

Free, really? No, with one exception. On 3 November 2026, the Claude for Open Source program offers six months of Ultra to maintainers and active contributors of widely used open-source projects (whose code is public). The "free" tricks found online connect Claude Code to another model, free or installed on your computer. Claude Code stays, but it's no longer an Anthropic model answering.

What to type: your first-week cheat sheet

To see everything Claude Code understands, type / in a session and the list appears. /help describes the commands. The ones that are useful from your first week:

These come from the terminal. In the desktop app, according to its documentation, most have an equivalent:

If you don't write your project's code yourself, the "explanatory" response style helps you follow what Claude does, by adding to each change a short explanation of its choices. You choose it in /config (in the app: Settings). There's also a "learning" style, which has you write small pieces of code, useful only if you want to learn to code.

Terminal, desktop app or VS Code: what changes

You chose a way in when you set up. Once you're at ease, you can try another. It's the same agent everywhere, with the same account and the same limits. From one to the next, what changes is how you choose the mode, how you review changes and where the work happens. To use Claude Code in the terminal, you type commands and keys. The desktop app puts the same controls under the box where you type.

In VS Code. Open the extensions panel (Cmd+Shift+X on Mac, Ctrl+Shift+X on Windows), search for "Claude Code" (Anthropic's extension) and click Install. It brings its own copy of Claude Code: no need to install it in the terminal as well to use it.

Then open a file from your project and click the spark icon at the top right of the editor, then sign in with your Claude account. A "Learn Claude Code" list then walks you through the extension step by step.

Cursor is a code editor built from VS Code. According to Anthropic's documentation, the same extension installs there: search for "Claude Code" in its extensions panel too.

The two rules set at the start of your first session hold in the app, the terminal and VS Code, which read the same settings file. They don't hold on the web, where Claude works on a machine at Anthropic, without your personal settings or your .env.

On the web, what Claude produces lands on a separate branch. Back on your computer, ask Claude, in the app or the terminal, to explain those changes, then add them to the main branch: it will ask for your OK before the upload.

Several sessions can run side by side, each on its own task. In the app, each works on its own copy of the project. In the terminal, two sessions open in the same folder change the same files: one can undo what the other just did.

It's not unusual for me to have more than ten open at once. When two of them have touched the same files, I ask Claude to bring their changes together and settle the conflicts, the places each changed in its own way, then save the version.

When you start, keep to one session at a time: you'll follow more easily what Claude changes.

What Claude Code changes in your work time

With Claude Code in hand, how much time does it save? The clearest gains are measured on well-defined tasks that repeat. They're smaller across the whole of the work. They also often start with time spent learning and setting up.

David Tavoularis hasn't written a line of code himself since August 2025, more than a year ago. In his company, his team measured three times the productivity on maintenance, meaning fixing and updating existing software. Across all research and development, the productivity gain is 50 to 60%: "it's not extraordinary for now either."

His biggest project shows what the gain looks like on a repetitive task: the same work, program after program. He had to modernize an old part of his company's software. He'd been told about ten programs needed updating. But at each one, Claude Code warned him that this program depended on others to modernize first. Once he had traced the whole chain, there were about 150.

The project stretched over two to three months, or "roughly 40" working days. He spent about an hour a day on it, letting Claude work at night and checking the result in the morning. At the end, Claude estimated a developer without AI would have spent "400 working days" on it.

400 days divided by 40 is the "factor of 10" he keeps, not counting that he himself spent only an hour a day on it. He adds at once: "maybe it's exaggerating, since it's the one that did the work."

The gain is sometimes paid for elsewhere. At Alan, developers reviewed the code AI wrote for Guillaume Maarek. That review could "take more time than if you had made the change yourself." The company accepted it, because that was the price of letting everyone build their skills.

Time saved often starts with time spent. Arthur Villecourt is "absolutely not a developer." He spent two months building his company's internal tools with Claude Code: dashboards, a keyword database, a sales tracker. In April 2026 his verdict was: "AI isn't saving me time today, it's burning my time."

He's betting on what comes next, once those tools are in place. He already has an example: a task that took him two weeks took four hours with Claude Code.

Tim, a freelancer who spent years building client apps on Bubble, a service for making apps without writing code, moved to Claude Code in March 2026. He began by rebuilding TrackHour, his own time-tracking software, with subscription and PDF reports: an app whose every screen he already knew.

The Bubble version had taken him "quite a long time." With Claude Code, "in a day at most, it was done", phone version included. He knew exactly what he wanted to get, and that's the kind of task where the gain is clearest.

Independent studies measure older AI than today's. In 2025, a controlled study by METR, an independent AI evaluation organization, found that sixteen experienced developers went 19% slower with the AI of the time, while believing they went faster.

In February 2026, METR had to rethink the method of its next study: too many developers refused to work without AI, even for the length of the experiment. Yet the study compares tasks done with and without AI. METR judges it "likely" that they're now faster, without being able to say by how much.

I no longer put a number on the time I save: it grows a little every day. When you start, though, counting is the only way to know whether you're really saving any, as Arthur Villecourt saw.

Count the total time of a task, from the first message to the checked result, including the time you spend checking it. Then compare it with what the same kind of task took you without Claude Code. If you've never done that kind of task without Claude Code, compare from one week to the next the time the same sort of task takes you.

Your action plan

Every action in this guide, in the order of the steps, to tick off as you go.