Claude Code & coding agents

Claude Code in the terminal: every mode and mod you can switch on (November 2026)

Auto mode has been on by default since late September, effort starts at medium and since October you can rebuild Claude Code itself with mods. Every switch in the terminal: what it does, what it costs and where it bites. With a mod I tested myself.

Erik van de Blaak
Erik van de Blaak
29 min read • 111 views
Claude Code in the terminal: every mode and mod you can switch on (November 2026)

Start claude in a terminal and look at the bottom line. It says ⏵⏵ auto mode on. You switched nothing on, yet a second model now decides whether Claude may run a command. That has been the default since late September, on every plan, as long as your model supports auto mode. Many people don't know, because the notice appears only once, at the top of your first session.

The same goes for more of Claude Code. New versions ship almost daily. Version 2.1.328 came out on the night of 18 to 19 November, and the changelog now runs to more than eleven thousand lines. Somewhere in there are switches that noticeably change your working day: how deeply Claude thinks, how fast it answers, whether it keeps going until a test passes, and since October even mods, pieces of code that let you rebuild Claude Code itself. This article walks through all of them: what each switch does, when to turn it on, what it costs and where it can bite you.

Checked on 19 November 2026 against the official documentation at code.claude.com, the Claude Code changelog and the release dates on npm. I use Claude Code 2.1.328 on Windows 11. I wrote, validated and ran the sample mod further down myself. The other descriptions come from the documentation and were not measured by me. This article was written with help from Claude Code.

Short answer. Keep auto mode on for daily work and press Shift+Tab to plan mode before you change anything big. Leave the effort level (/effort) at medium and only raise it for hard bugs. Use /goal when the work has a measurable end point. Fast mode, ultracode and the advisor cost extra, so turn them on deliberately. Code Mode has been available as an experiment since 12 November. Mods add real features to Claude Code, but they run with your permissions and without a sandbox. On a personal plan they can also get around part of your permission rules. So read a mod before you install it.

Mode, mod or setting: what is what?

The words get mixed up in Claude Code, which makes it confusing. "Auto mode", "fast mode", "Code Mode" and "plan mode" sound like four positions of one dial. They aren't. They act in different places, and you can turn most of them on at the same time.

WhatWhat it controlsHow to turn it on
Permission mode (manual, acceptEdits, plan, auto, dontAsk, bypassPermissions)What Claude may do without asking youShift+Tab or --permission-mode
Effort (low to max)How much the model reasons per step/effort or --effort
UltracodeWhether Claude spreads big tasks over dozens of subagents with a script/effort ultracode
Fast modeThe same model, faster and more expensive/fast
AdvisorA second, stronger model that weighs in at key moments/advisor
/goalKeep working across turns until a condition holds/goal <condition>
Code ModeClaude writes JavaScript that calls its toolsEnvironment variable, experimental
Fullscreen and output stylesWhat the screen and the answers look like/tui, /output-style
ModsPlugins that change Claude Code itself: panes, commands, rules for tools/plugin

I cover them in this order. You meet the first two every day; the last one is the newest.

Permission modes: who approves what Claude does?

A permission mode sets which actions Claude may take without your approval. You switch during a session with Shift+Tab. From auto mode the first press goes to manual, then acceptEdits and plan follow, and then you are back at auto. The status bar shows where you are.

The six permission modes of Claude Code and what each allows without asking. Manual: reads only. acceptEdits: reads, file edits and simple file commands. Plan: reads and exploration, edits only after the plan is approved. Auto: everything, with a classifier model checking each action. dontAsk: only pre-approved tools, everything else is denied. bypassPermissions: everything, meant for containers only. Shift+Tab cycles through auto, manual, acceptEdits and plan.
ModeWhat runs without askingUse it for
Manual (default)Reads onlySensitive work, code you don't know
acceptEditsReads, file edits, mkdir, mv, cp and similarCode you review right away
planReads and exploration; edits only after you approveUnderstand first, then build
autoEverything, but a second model checks every risky actionLong tasks, fewer prompts
dontAskOnly what you allow up front; the rest is deniedScripts and CI
bypassPermissionsEverythingOnly in a container or VM

What auto mode really does

In auto mode you no longer approve each command. A classifier does: a separate model, Claude Sonnet 5 by default, that holds each action up against your request. Reads and edits inside your project folder usually go through without a check. Everything else passes the classifier. According to the documentation it blocks, among other things: curl | bash, a force push, git reset --hard and other commands that throw away uncommitted work, production deploys and migrations, sending sensitive data out, terraform destroy, and merging a pull request no human has approved.

Two details are not on the first page of the documentation, but they matter in practice.

First, the classifier listens to what you say in the conversation. Write "don't push until I've looked" and it blocks a push, even one the default rules would allow. But such a boundary is not a rule. The classifier rereads it from the conversation on every check. If Claude Code clears that part of the conversation when compacting, the boundary is gone. If you need certainty, put it in your settings as a deny rule.

Second, auto mode falls back to prompting when the classifier blocks something three times in a row or twenty times in total. That is often not Claude's fault. Usually the classifier doesn't know your infrastructure. You can see what was blocked in /permissions under Recently blocked, where you can still approve an action.

There is also a trap in the settings. "defaultMode" set to auto or bypassPermissions doesn't work from the project files .claude/settings.json and .claude/settings.local.json. That is deliberate: otherwise a repository you clone could grant itself wider permissions. You get no error message. With bypassPermissions the session starts in manual. With auto the built-in default applies, and a defaultMode from your own ~/.claude/settings.json is ignored as well. So if you set manual in your user settings and auto in a project, you start in auto.

The documentation says it itself: auto mode "reduces permission prompts but does not guarantee safety". On Windows there is one more thing. The sandbox for shell commands works on macOS, Linux and WSL2, but not on native Windows. There commands run unsandboxed, and the classifier is your only safety net.

Plan mode: think first, build later

In plan mode Claude reads, explores and writes a plan. Your source code stays untouched until you approve the plan. You get there with Shift+Tab, or you put /plan in front of a single prompt. When the plan is ready, you choose: approve and continue in auto mode, approve and review each edit yourself, or keep planning.

Ctrl+G opens the plan in your own editor, so you can change it before Claude starts. That is also where the classic mistake happens. On the approval screen, Shift+Tab approves the plan. Press Shift+Tab out of habit to switch modes, and you start execution. Press Esc first.

Plan mode saves the most work when you don't know a codebase or a change touches many files. For a small fix it is overkill: the plan ends up longer than the change.

Effort: how much does Claude think?

Effort sets how much the model reasons per step. The levels are low, medium, high, xhigh and max. Higher means more thorough, but also slower and more tokens. Opus 5.5, the default model on all plans, starts at medium. On most older models high was the default. That is less bad than it sounds. A level means something different per model, and according to Anthropic Opus 5.5 at medium matches or exceeds Opus 5 at high.

LevelWhen (according to the documentation)
lowQuick questions, a first sketch, a rename
mediumDefault. Day-to-day work with a clear scope, such as building a new feature
highWork where verification matters, such as a bug in existing code
xhighDeeper reasoning at higher token spend
maxThe deepest level; applies to the current session only

A few handy details. Type /effort without an argument for a slider. Enter saves the level as the default for that model, s applies it to this session only. To think harder once without changing your setting, put the word ultrathink in your prompt. Phrases like "think hard" are not recognised as keywords; they go through as plain text. /effort auto clears your saved level.

My advice: start at medium and only go up when Claude misses something you expected it to catch. A higher level doesn't fix an unclear request. The model just thinks longer about the wrong question.

Ultracode: dozens of agents with one switch

Ultracode is not an effort level, even though it sits in the same menu. With ultracode on, Claude spreads a big job over a dynamic workflow: a JavaScript script that Claude writes itself and that drives dozens to hundreds of subagents in the background. The intermediate results live in the script's variables, not in your conversation's memory. So your context window doesn't fill up, and you can rerun the script later.

Turn it on with /effort ultracode, or with Tab in the slider. claude --effort ultracode starts straight at xhigh with ultracode on. To see how such a workflow works first, try the built-in /deep-research with a question. It searches for sources from several angles, cross-checks them and returns a cited report. /workflows shows the progress.

A workflow for an audit of the whole codebase or a migration of five hundred files is exactly what this is for. For a bug fix in one file it is too much: every agent uses tokens, and you pay for the agents talking to each other. So I turn ultracode on per task and off again afterwards.

Fast mode: faster, same model, more expensive

Fast mode is the same model with a different API configuration. According to Anthropic it is up to 2.5 times as fast, and the quality stays the same. You turn it on with /fast, and a ↯ appears next to the prompt. On the Anthropic API it works on Fable 5.2 and Opus 5.5, and as a research preview on Opus 5 and Opus 4.8, not on Sonnet or Haiku. Fast mode for Opus 4.8 goes away on 30 November 2026. If you are on a model without fast mode, /fast switches you to Opus.

It does cost more. Fast mode with Opus 5.5 costs $8 per million input tokens and $40 per million output tokens; with Fable 5.2 it is $16 and $80. On a Pro, Max, Ultra, Team or Enterprise plan, fast mode is always paid from your usage credits, not from the limits included in your plan. Usage credits must be turned on, and on Team and Enterprise an Owner has to enable fast mode first.

Turn fast mode on at the start of a conversation, not halfway through. Fast mode and normal speed each have their own prompt cache. The first time you switch, you therefore pay the full fast rate for all the context that is already there. The longer the conversation, the more expensive that switch. Fast mode is useful for live debugging and quick iteration, when you are waiting on every answer. For a task that runs in the background for an hour, it does nothing for you.

The advisor: a second opinion at the right moment

With /advisor opus or /advisor fable, Claude gets an advisor. That is a second model that Claude consults itself at moments that matter: before it commits to an approach, when the same error keeps coming back, or before it says something is done. The advisor reads the whole conversation and gives advice, which Claude applies. The advisor must be at least as strong as your main model. With Opus 5 or 5.5 as the main model, only Fable and Opus 5 or later qualify. Claude Code shows Advisor Tool (experimental) and warns that it may use more tokens.

It works best on long tasks where most steps are routine, but the plan decides the outcome. A big refactor, or a bug that still comes back after three attempts. On short tasks it adds little.

/goal: keep going until it holds

Claude stops when it thinks it is done, and that is not always the moment you had in mind. With /goal you set an end condition. After every turn a separate model checks whether that condition holds. If not, Claude starts a new turn by itself.

/goal all tests in tests/Feature/Auth pass, "composer lint" exits 0, and no other test file has been changed

A good condition has one measurable end point, says how Claude proves it and names what must not change. The checking model doesn't run any commands itself. It only reads what Claude shows in the conversation. So "the code is clean" doesn't work; "npm test exits 0" does. If you want a limit, add "or stop after 20 turns". /goal without an argument shows the status, /goal clear stops it.

Important: /goal doesn't change your permission mode. In manual, Claude keeps asking for approval, and you end up pressing a key every few minutes anyway. The two complement each other. Auto mode removes the prompts per tool, /goal the prompts per turn. For an unattended run you need both. Letting Claude Code work autonomously covers how to set up such a run and where it goes wrong.

Code Mode: Claude writes code to call its tools

Code Mode is the newest experiment. It shipped on 12 November, in version 2.1.323. Normally Claude requests one tool, waits for the result and then decides what comes next. In Code Mode Claude writes a piece of JavaScript that calls several tools, can run commands in parallel and returns only the part of the output Claude needs. The example from the documentation:

const files = await $`rg -l "function retryPolicy" src`.text();
const target = files.trim().split("\n")[0];
await edit(target, "maxAttempts: 3", "maxAttempts: 5");
({ edited: target, tests: $`npm test -- retryPolicy`.nothrow() });

In the conversation you just see the edits. You see the code itself with Ctrl+O. You turn it on with the environment variable CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1. The first time, Claude Code asks for confirmation and restarts.

The requirements are strict. You need the native build, version 2.1.323 or later, Opus 5.5, Sonnet 5.5, Haiku 5.5 or Fable 5.2, and an interactive terminal session. Among other things, it doesn't work with -p, the Agent SDK, VS Code, the Desktop app or cloud sessions, nor through Bedrock, a gateway or with DISABLE_TELEMETRY. On Windows you need Git for Windows, because the shell commands in the scripts run in Git Bash. Remote Control, Claude in Chrome and computer use don't work in Code Mode, and such a session can only be resumed with Code Mode on.

This is the main trade-off. In auto mode, the classifier reviews a Code Mode script once, as a whole. The individual tool calls inside it are not checked separately. deny and ask rules keep working, but the documentation warns that Claude can then write Bash commands in forms your rules don't match. That last point really holds everywhere: Bash rules look at the text of a command, with or without Code Mode. The real difference is in the classifier. It doesn't see values computed at run time, such as a path taken from a search result. So for what you really want to stop, use the sandbox or a hook, not a text rule.

My advice: try Code Mode on a repository where nothing can break, for tasks with many small steps. Think of the same change across forty files, or search results that need filtering first. That is where the gain is biggest. For work where you want to see every step, wait until the experiment has matured.

The screen and the tone

Fullscreen: no more flicker

Does your terminal jump to the top while Claude works, or does the screen flash during long output? Type /tui fullscreen. If you first used Claude Code on or after 6 May 2026, you often start in it by default already. Claude Code then draws on the terminal's alternate screen, like vim and htop. It draws only what is visible, memory use stays flat in long conversations, and you can use the mouse. The difference is largest in the VS Code terminal, in tmux and in iTerm2. /tui default takes you back. Fullscreen is still a research preview.

Output styles: how Claude talks to you

/output-style picks one of the four built-in styles next to the default. Proactive starts right away and makes routine decisions itself. Concise leads with the result and drops the preamble and recap. Explanatory adds short blocks explaining the choices made. Learning leaves small pieces of code for you to write yourself. That last one is handy if you are learning a new language and want to keep programming yourself. Keep in mind: an output style is an instruction, not a guarantee. What must always happen belongs in a hook.

Three keys worth knowing

  • Esc Esc on an empty prompt opens the rewind menu. It restores the code, the conversation or both to an earlier point. Claude Code keeps file snapshots for the last hundred checkpoints, by default for about thirty days. A file that only shell commands changed is not restored; that is what Git is for.
  • Ctrl+O opens the full transcript, with the Code Mode code, the reasons behind /goal verdicts and the details of every tool call.
  • /btw asks a side question about the session that doesn't end up in the conversation. That keeps your context clean.

Mods: rebuilding Claude Code itself

Since version 2.1.287, released on 1 October, a plugin can contain a mod. A mod is JavaScript or TypeScript that runs inside Claude Code. Claude Code calls your functions on events: Claude wants to use a tool, you submit a prompt, or part of the screen is drawn. Your function can watch, change the event or take it over entirely.

That sounds like the hooks you already knew, but the difference is large. A regular hook in settings.json is a separate command, HTTP request or prompt that watches from outside. A mod runs in the process itself. It can draw a pane beside the conversation, a band above the prompt, buttons and input fields. It can add a /command that works at once, without Claude needing a turn. And it can hold a tool call while it asks you something.

Diagram of a mod in Claude Code. Claude wants to use a tool, for example Bash with git push --force. The tool.call event first passes the mod's hook. The mod can observe and call next, rewrite the call and then call next, or answer itself with deny without calling next. Only through next do the permission check and then the tool itself follow. With deny, Claude reads the reason as the result.

Built-in mods

Part of Claude Code is itself built as mods. In /plugin, on the Installed tab, they are listed under Built-in. A few examples from the documentation:

Name in /pluginWhat it doesDefault
cc-plugin-diffDraws the /diff paneOn in interactive terminal sessions
cc-plugin-agents-mdLoads AGENTS.md as project instructionsOn
cc-plugin-sec-defaultGuards what your organisation manages against mods you install yourselfOnly with managed settings or a Team or Enterprise login; can't be turned off
cc-plugin-you-should-knowA side agent that reads along and puts a short warning above the prompt when it spots something you might missOff

That last one is the mod most people will turn on themselves:

/plugin enable cc-plugin-you-should-know@builtin

During a longer task a side agent rereads the conversation from time to time. When it sees something you should know, such as a trade-off Claude made silently or a result that looks off, a line starting with ✦ Heads up appears. The side agent has no tools, so it can't read, run or change anything. It isn't free. Each check is a request to the same model and counts toward your limits. The conversation mostly comes from the prompt cache, but the mod's instructions (several thousand tokens) and the reply are billed in full on every check. It only shows up if you connect directly to the Claude API with telemetry on. Behind a gateway or with DISABLE_TELEMETRY it is not listed. On my machine, claude plugin details cc-plugin-you-should-know@builtin lists it. It shows "~0 tok" of fixed cost, but that number only covers what always sits in your context, not the checks themselves.

A mod of my own, tested

To see whether it really is as simple as the documentation promises, I wrote a small mod: push-guard. It refuses every force push. For a push to main or master it asks for confirmation first. And it counts Claude's tool calls, which you query with /tally. No Node.js, bundler or build step needed; Claude Code loads the .js file directly. A mod consists of three files:

push-guard/
├── .claude-plugin/
│   └── plugin.json
└── hooks/
    ├── hooks.json
    └── register.js

.claude-plugin/plugin.json is the plugin's manifest (the description is in Dutch, as in my test):

{
  "name": "push-guard",
  "version": "0.1.0",
  "author": { "name": "Erik van de Blaak" },
  "license": "MIT",
  "description": "Weigert force-pushes, vraagt eerst bij een push naar main of master, en telt Claudes toolaanroepen (/tally)"
}

hooks/hooks.json points to the code. It is the modules key that turns a plugin into a mod:

{
  "description": "push-guard hooks module",
  "modules": ["./register.js"]
}

And hooks/register.js holds the mod itself. This is the exact file I tested, so the comments and messages are in Dutch; the translation follows below the code.

// Gedeeld door alle hooks hieronder
let calls = 0

// Force-push: --force, --force-with-lease, -f, of een refspec met + (git push origin +main)
const FORCE = /\bgit\s+push\b.*(\s--force\b|\s--force-with-lease\b|\s-f\b|\s\+\S)/
// Een push die main of master noemt
const MAIN = /\bgit\s+push\b.*\b(main|master)\b/

export function register(on) {
  on('session.start', async ($, e, next) => {
    await $.command.register({
      name: 'tally',
      description: 'Laat zien hoeveel tools Claude deze sessie heeft aangeroepen',
    })
    return next(e)
  })

  // Elke toolaanroep tellen, en de teller naast de spinner zetten
  on('tool.call', async ($, e, next) => {
    calls += 1
    $.ui.invalidate('ui.render')
    return next(e)
  })

  // Alleen Bash: force-push weigeren, push naar main eerst voorleggen
  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
    if (FORCE.test(e.command)) {
      return { deny: 'Force-push is hier uitgeschakeld. Push naar een nieuwe branch en open een pull request.' }
    }
    if (MAIN.test(e.command)) {
      let answer = 'Weigeren'
      try {
        answer = await $.ui.ask('Claude wil pushen naar main/master: ' + e.command, ['Pushen', 'Weigeren'])
      } catch {
        // Vraag weggeklikt, of claude -p zonder iemand om te vragen
      }
      if (answer !== 'Pushen') {
        return { deny: 'De gebruiker wil niet direct naar main/master pushen. Gebruik een feature-branch.' }
      }
    }
    return next(e)
  }).catch(() => ({ deny: 'push-guard kon dit commando niet controleren en weigert het daarom.' }))

  on('command.run', { command: 'tally' }, async () => {
    return { text: 'Claude heeft ' + calls + ' tools aangeroepen sinds deze mod laadde' }
  })

  on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
    return next({ ...e, props: { ...e.props, suffix: ' · tools: ' + calls + '…' } })
  })
}

In English: the force-push refusal says "Force push is disabled here. Push to a new branch and open a pull request." The question is "Claude wants to push to main/master", with the options "Push" and "Refuse"; if the answer isn't "Push", Claude reads "The user does not want to push directly to main/master. Use a feature branch." The fallback in .catch reads "push-guard could not check this command and therefore refuses it", and /tally prints how many tools Claude has called since the mod loaded.

Every hook gets three things. $ is the mods API: everything a mod can do outside its own code, such as drawing, registering a command or asking a question. e is the event, for example the tool name and e.command for Bash. next passes the event on to the next mod and eventually to Claude Code itself. A hook that calls next lets the action continue. A hook that returns something without calling next takes the action over. In that case no permission prompt appears and the tool doesn't run.

Note the .catch on the Bash hook. If a hook throws or takes too long, Claude Code skips it and the command simply goes ahead. For a guard that is exactly wrong. With .catch, the mod refuses the command when it can't check it. The validator points this out: for my counting hook it reports gating hook without .catch. For a hook that only counts, that is fine.

This is how I checked it on Windows 11 with Claude Code 2.1.328. First the static check, which runs nothing:

claude plugin validate ./push-guard
  ❯ ./register.js hooks: session.start, tool.call, tool.call{tool=Bash}, command.run{command=tally}, ui.render{component=Spinner}
  ❯ ./register.js answers its own command: command.run{command=tally}
  ❯ ./register.js gating hook without .catch: tool.call
  ❯ ./register.js gating hook with .catch: tool.call{tool=Bash}
  ❯ ./register.js calls: $.command.register, $.ui.ask, $.ui.invalidate
✔ Validation passed

Then the command, in a throwaway repository, without Claude needing a turn:

PS> claude -p "/tally" --plugin-dir .\push-guard
push-guard: Claude heeft 0 tools aangeroepen sinds deze mod laadde

Next I gave the throwaway repository a local remote and let Claude push, with an allow rule for Bash(git push *), so that only the mod could still stop it. This is what happened:

CommandResult
git push --force origin mainRefused: Force-push is hier uitgeschakeld. Push naar een nieuwe branch en open een pull request.
git push origin +HEAD:refs/heads/test-plusRefused with the same message (a + in the refspec is a force push too)
git push origin mainRefused: in claude -p nobody is there to answer the question, so $.ui.ask fails and the mod falls back to "Refuse"
git push origin HEAD:refs/heads/feat-testRan; the branch feat-test was on the remote afterwards

Three things stood out. First, Git Bash on Windows silently turns /tally into the path C:/Program Files/Git/tally. So Claude received a path instead of a command. PowerShell gets it right, and in Git Bash MSYS_NO_PATHCONV=1 helps.

Second, the regex is only as good as you make it. The example in the documentation misses git push -f, and my first version missed +main. Even now some cases go wrong. git push origin main:feat-test pushes to a feature branch, but is treated as a push to main. git -C ../other push --force and git push origin HEAD from main slip through. A mod that reads commands as text is an extra layer. A hard boundary is branch protection on the server.

Third: when I asked Claude in one prompt to try a force push and +main, it didn't even run the second one. It saw it as a way around the first refusal. That is pleasant behaviour, but it is the model's behaviour, and you don't build security on it.

You don't have to write a mod yourself. In a session, ask for example "make a mod that shows the current git branch above the prompt". Claude then uses the built-in plugin-authoring skill, writes the mod in ~/.claude/dev-mods/ and asks whether it may load it right away. You only get that question in manual and acceptEdits. In auto mode, Claude Code loads a mod that Claude wrote without asking. Since a mod can partly get around your permission rules, that is a reason to switch to manual for this kind of work.

Anthropic also shares sample mods in the claude-code-playground repository, such as blast-radius. It holds risky commands and first shows what they would change.

Read a mod before you install it

This is the part missing from enthusiastic posts about mods. A mod runs with your permissions and has no sandbox. It can read and write your files, start programs, go on the network and read your environment variables, API keys included. It sees every prompt and every tool call. And the Bash sandbox doesn't apply to processes a mod starts itself.

Then the question of who has the final say: your deny rules or a mod. That depends on the built-in guard cc-plugin-sec-default, and it doesn't always load. According to the documentation it loads only when the machine has managed settings or a managed-mcp.json, or when your session runs on a Team or Enterprise login. If you work on your own with Pro or Max, or with an API key, there is no guard. The same goes for a session on a long-lived CLAUDE_CODE_OAUTH_TOKEN. A mod can then approve a call that a PreToolUse hook blocked, and even some calls a deny rule refuses. Even with the guard there is a gap. A mod that calls $.fs.read itself reads your .env even when Read(.env) is denied. Your permission rules apply to Claude, not to the mod.

Fortunately you can see what a mod does without running it: claude plugin validate ./some-mod shows the same hooks: and calls: lines as above. See $.http.fetch, $.fs.read or $.process.spawn in a mod that supposedly only colours your spinner? Don't install it. If something goes wrong, claude --safe-mode starts a session without your own customisations. "disableAllHooks": true in ~/.claude/settings.json turns off all your installed mods and hooks everywhere. Your custom status line and /goal stop too, since the latter runs on the same hooks system. Built-in mods stay on.

Which switches I would pick per situation

This is my advice, not a measurement. It suits a developer working alone or in a small team in their own repository.

SituationHow I set it up
A codebase I don't knowPlan mode, effort medium, have it explained first and only then let anything change
Building, day to dayAuto mode, effort medium, /clear between unrelated tasks
A stubborn bugEffort high or ultrathink in the prompt; /advisor after repeated failure
A job with a measurable endAuto mode plus /goal with a test as proof and a turn limit
An audit or big migrationUltracode, and decide up front what must not change
Live debugging while I waitFast mode, turned on at the start of the conversation
A repository with production consequencesManual, or auto with deny rules for deploy and push, plus a guard mod as an extra layer
CIclaude -p with --permission-mode dontAsk and an exact --allowedTools list

Mistakes to avoid

  • Thinking you are in manual. Since late September an interactive session starts in auto. Check the status bar.
  • Setting a boundary only in the conversation. "Don't push" works until the conversation is compacted. A deny rule stays.
  • defaultMode in project settings. auto and bypassPermissions are silently ignored there. With auto the built-in default applies, and your own choice in ~/.claude/settings.json is dropped too.
  • Shift+Tab on the plan mode approval screen. That approves the plan. Esc first.
  • Leaving effort high. max lasts only for the session, but xhigh is saved as your default when you press Enter. After that, every small question runs at the expensive level.
  • Turning on fast mode halfway through a long conversation. You pay for the whole context again at the fast rate.
  • Installing a mod without validate. It takes ten seconds and shows what the mod touches.
  • Thinking your deny rules also apply to mods. They apply to Claude. Without a Team or Enterprise login or managed settings, a mod can partly get around them.
  • Counting on the sandbox on Windows. It only exists there in WSL2.

Frequently asked questions

Which version of Claude Code do I need for all this?

2.1.287 or later for mods, 2.1.323 or later for Code Mode. The newest version on 19 November 2026 is 2.1.328. Check with claude --version and update with claude update. On the stable channel (currently 2.1.311) you are a few weeks behind.

Is auto mode safe?

Safer than working without checks, but not watertight. A second model blocks destructive and risky actions by default, such as force pushes, git reset --hard, production deploys and sending secrets out. Anthropic says itself that it "does not guarantee safety". For what must never happen, use deny rules.

What is the difference between a mod and a hook?

A hook in settings.json is a separate shell command, HTTP request or prompt that runs on an event. It can say yes or no, change arguments or add context. A mod is JavaScript or TypeScript that runs inside Claude Code. A mod can also draw, add commands, rewrite or hold tool calls, and call a model itself.

Can a mod get around my permission rules?

Partly, yes. Without managed settings or a Team or Enterprise login, the built-in guard doesn't load. A mod can then approve calls that a PreToolUse hook blocked, and some calls that a deny rule refuses. Even with the guard, a mod can read files and start programs through its own API, outside your rules. Only install mods you have read or whose author you trust.

Does fast mode cost extra on a Max plan?

Yes. On Pro, Max, Ultra, Team and Enterprise, fast mode is always paid from your usage credits, not from your plan's included limits, and those credits must be turned on. With Opus 5.5 it costs $8 per million input tokens and $40 per million output tokens.

Does Code Mode work on Windows?

Yes, with the native build and Git for Windows, because the shell commands in Claude's scripts run in Git Bash. Among other things, it doesn't work in the VS Code extension, with claude -p or through Bedrock or a gateway.

Further reading on this site

Sources

Official documentation (Anthropic, accessed 19 November 2026)

Releases

Own test

  • The push-guard mod was written and tested on 19 November 2026 with Claude Code 2.1.328 on Windows 11. claude plugin validate passed and /tally ran via claude -p. In a throwaway repository with a local bare remote, four pushes were run: three were refused and one arrived. Eleven command variants were also tested against the regexes.

Share this article

Erik van de Blaak

Written by

Erik van de Blaak

AI Solutions Engineer & Full-Stack Developer

Erik van de Blaak is an AI Solutions Engineer and full-stack developer at CareerValue BV. Here he writes about AI coding tools and agents, such as Claude Code.

Comments (0)

Comment on this article

Never published

I read every comment before it goes online.

No comments on this article yet.