# Claude Code Skip Permission Confirmation

> The options for reducing Claude Code's permission prompts — the per-session flags, fine-grained pre-authorisation in settings.json, and what a global bypass actually turns off.

Source: https://chanmeng.org/blog/claude-code-skip-permission-confirmation
Author: Chan Meng — https://chanmeng.org
Published: 2026-06-16
Tags: Claude Code

---

*Originally written as internal engineering notes while building the thing it describes. Republished here with light editing — the timeframe is noted where it matters.*

## Problem

During Claude Code usage, frequent permission confirmation prompts (e.g., Bash command execution, file editing) require manually selecting "Yes", which interrupts the development workflow.

## Solution

### Temporary (Current Session Only)

```bash
# Option 1: Dedicated flag, same effect as Option 2
claude --dangerously-skip-permissions

# Option 2: General parameter, bypassPermissions is one of the available values
claude --permission-mode bypassPermissions
```

Both options have the same effect — they skip all permission prompts. The only difference is the entry point: one is a shortcut flag, the other is a specific value of a general parameter.

### Persistent, Fine-Grained (Recommended)

Rather than switching the checks off, pre-authorize the tools you actually get asked about, in `~/.claude/settings.json`:

```json
{
  "permissions": {
    "defaultMode": "acceptEdits",
    "allow": [
      "Bash(*)",
      "Read",
      "Write",
      "Edit"
    ]
  }
}
```

`acceptEdits` automatically accepts file edits, and `Bash(*)` covers Bash command confirmations. Everything not on the `allow` list still prompts — which is the point: the prompts you kept are the ones for things you didn't anticipate.

Narrow the entries further as you learn your own patterns. `Bash(git *)` or `Bash(npm run *)` removes most of the noise while leaving an arbitrary shell command as something you still get to see before it runs.

### Persistent, Global Bypass (If You Accept the Risk)

The blunt version — applies to every project on the machine:

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

Worth being clear about what this turns off. The permission prompt is the only place where a command is shown to you *before* it executes — so bypassing it means file writes outside the project, `rm`, `curl` to an arbitrary host, `git push`, and anything an agent picked up from a file it read all run without you seeing them first. That last case is the one to weigh: an agent acting on instructions embedded in a repository, a web page, or a dependency's README is exactly the scenario the prompt exists to catch.

I use it only in throwaway containers and sandboxes. On a machine holding real credentials or a real repo, the fine-grained setup above is the better trade.

## permission-mode Available Values

| Value | Behavior |
|---|---|
| `default` | Default, confirms each action individually |
| `acceptEdits` | Automatically accepts file edits |
| `bypassPermissions` | Skips all permission checks |
| `plan` | Plan only, no execution |
| `dontAsk` | Don't ask, skips when no permission |

## Summary

Start with the `allow` list. It removes the prompts that are pure friction — the ones you would have approved without reading — and keeps the ones that are actually doing a job. `bypassPermissions` skips **all** of the checks, and is only a sensible default in an environment you would be willing to throw away.