---
title: "Claude Code Auto Mode Is Now the Default: Check, Disable, Debug"
description: "Claude Code now starts in auto mode in the terminal and VS Code. Here is how to check your mode, pin manual mode, and debug blocked or \"Not run\" commands."
url: https://cdnping.org/en/blog/claude-code-auto-mode-default
language: en
published: 2026-10-19
category: "Developer tools"
tags: ["Claude Code","auto mode","permission modes","classifier","developer tools"]
source: cdnping.org
license: Free to quote and summarize with a link to the url above.
---
# Claude Code Auto Mode Is Now the Default: Check, Disable, Debug

As of October 2026, Claude Code 2.1.283 and later starts in auto mode whenever no permission mode is specified, in both the terminal and VS Code. Commands are no longer confirmed one by one. Instead, a separate model, the classifier, decides whether to allow or block each one. To go back to per-command confirmation, set `permissions.defaultMode` to `default`. To opt out of the server-side classifier, set `CLAUDE_CODE_AUTO_MODE_SERVER=0`. This article is based on version 2.1.302, released October 16. Everything below comes from Anthropic's official docs and changelog; check your own version with `claude --version`.

## What actually changed when auto mode became the default?

The official [permission modes documentation](https://code.claude.com/docs/en/permission-modes) says that from 2.1.283, auto mode is the built-in starting mode for interactive terminal and VS Code sessions. Earlier versions did this only for Pro, Max and Team plans, and only in sessions that could fetch feature flags.

A few points that are easy to mix up:

- In auto mode, the classifier reviews actions that would otherwise need your confirmation. Low-risk operations such as reads do not go through it.
- Defaults differ by entry point. `claude -p` and the Agent SDK default to `default` in sessions that can fetch feature flags. The 2.1.302 changelog adds that on third-party providers, with telemetry off, or on a fresh install, `claude -p` and SDK sessions with no configured permission mode also start in `default`. Passing `--permission-mode auto` explicitly still gives you auto.
- If your `~/.claude/settings.json` already sets a non-auto `defaultMode`, sessions keep starting with it.
- Auto mode has prerequisites (a supported model, not disabled by an admin, not turned off server-side, and so on). When they are not met, Claude Code says auto mode is unavailable and the session stays off; start a new session and try again. See the official docs for details.

## What is the server-side classifier, and how do you opt out?

There are two classifier sources: the client-side classifier, where Claude Code makes its own request, and the server-side classifier, where the review is done on the server together with the session's request. The docs state that when connecting directly to the Anthropic API, `-p`, the SDK, VS Code and the desktop app need 2.1.281 or later. From 2.1.282, sessions that do not fetch feature flags (for example, with telemetry turned off) use server-side review by default.

To pin the client-side classifier:

```bash
export CLAUDE_CODE_AUTO_MODE_SERVER=0
```

2.1.302 added `CLAUDE_CODE_AUTO_MODE_MODEL`, which sets the model used by the client-side classifier. It does not affect the server-side classifier. For the accepted value format, see the [environment variables docs](https://code.claude.com/docs/en/env-vars).

## How do you check the current mode and pin manual mode?

Press `Shift+Tab` to cycle through modes during a session; the UI shows the current one. Manual mode is labeled Manual in the interface, and its config value is `default`.

To make every terminal session on your machine start in manual mode, add this to `~/.claude/settings.json`:

```json
{
  "permissions": {
    "defaultMode": "default"
  }
}
```

To change a single session only, use `claude --permission-mode default`. The command-line flag takes precedence over `defaultMode` in settings files, and the built-in default comes last.

Two gotchas:

- Putting `"auto"` in a project's `.claude/settings.json` or `.claude/settings.local.json` has no effect. It has to go in `~/.claude/settings.json`.
- To disable auto mode entirely for a team, an administrator must set `permissions.disableAutoMode` to `"disable"` in managed settings.

## A command was blocked or shows "Not run". How do you find out why?

First work out who blocked it. Go through this checklist:

| Symptom | Likely cause | What to do |
| --- | --- | --- |
| Gray "Not run" | Since 2.1.296, calls for which the classifier gave no usable verdict are shown in gray rather than as a red error | Retry; if it keeps happening, see the next rows |
| Message that the server returned no safety verdict | The review result was dropped or rewritten by a gateway or proxy, or the server-side check timed out | See the official [error reference](https://code.claude.com/docs/en/errors#the-server-returned-no-safety-verdict); behind a gateway, try `CLAUDE_CODE_AUTO_MODE_SERVER=0` |
| Everything is denied after a long conversation | The context is too long for the classifier to review | Upgrade to 2.1.302, which compacts before reviewing |
| Routine operations keep getting blocked | The target repo or service is outside the trusted scope | See [Configure auto mode](https://code.claude.com/docs/en/auto-mode-config) and declare trusted infrastructure in `autoMode.environment` |
| Unclear whether a rule or the classifier blocked it | Either could have | Turn on OpenTelemetry and look at the `tool_decision` event |

Since 2.1.301, the `tool_decision` event carries `classifier_verdict` and `permission_mode`, which tell you whether the decision came from the classifier or from a permission rule. With `OTEL_LOG_TOOL_DETAILS=1` set, it also includes `classifier_category`, which names the built-in rule that matched. 2.1.302 fixed that field being missing on most classifier blocks.

You can also run `claude auto-mode defaults` to print the full JSON of the built-in rules for comparison.

## Did connection errors or slowness after upgrading come from auto mode?

Not necessarily. The classifier only affects permission decisions. Network timeouts, 529 errors and quota problems are a different class of issue. Start with [cdnping's Anthropic status page](/en/status/anthropic) and the [Claude Code availability page](/en/down/claude-code), then work through the [Claude Code connection troubleshooting checklist](/en/blog/claude-code-connection-troubleshooting) layer by layer. For 529 errors, see [how to configure the new retry watchdog and idle compaction](/en/blog/claude-code-529-overloaded-retry-idle-compaction). For early-October anomalies, compare against the [September 29 outage and the October 7 spend-limit misjudgment](/en/blog/claude-code-outage-sep29-spend-limit-oct7). If you use Claude Code through a custom endpoint, read the [custom API configuration guide](/en/blog/configure-custom-api-endpoint-claude-code-codex); defaults on third-party providers differ from direct connections, so follow the official docs. For another approach to running agent commands in a sandbox, see [Copilot local sandboxing](/en/blog/github-copilot-local-sandboxing-ga). Anthropic's release notes are also tracked on [cdnping's changes page](/en/changes).

## Should you turn auto mode off?

It depends on the situation. Auto mode exists to interrupt you less, and the cost is handing approval to a model. For sensitive repositories, production credentials or unfamiliar code, Manual is safer. For everyday iteration in local projects, keeping auto with a well-configured trusted scope is usually enough. Either way, try a few blocked cases in an unimportant directory first, then decide.

## References

- [Claude Code changelog (2.1.296, 2.1.301, 2.1.302, etc.)](https://code.claude.com/docs/en/changelog)
- [Choose a permission mode](https://code.claude.com/docs/en/permission-modes)
- [Configure auto mode](https://code.claude.com/docs/en/auto-mode-config)
- [Environment variables](https://code.claude.com/docs/en/env-vars)