Looking to enable auto accept in Claude? This guide covers everything you need to know about auto-accepting tool permissions and file edits across both Claude Code (the CLI and VS Code extension) and Claude Desktop. Whether you want to toggle auto-accept mode with a keyboard shortcut or configure permanent tool approvals, we’ve got you covered.

Quick Answer: In Claude Code, press Shift+Tab to toggle auto-accept mode. In Claude Desktop, click the “Always approve” button when prompted for tool permissions.

Important Security Considerations

Before enabling any auto-accept features, consider these guidelines:

Auto-accepting removes security checkpoints – You won’t be prompted before Claude executes operations
Start with read-only tools – Begin with non-mutating operations like file reading and searching
Avoid auto-accepting expensive operations – Be cautious with tools that can incur API costs or modify/delete important data
Review your setup regularly – Periodically audit which tools have auto-accept enabled
Test carefully – Manually test new tools before enabling auto-accept
Use appropriate models – Sonnet 4.5 is recommended for better context awareness with auto-accepted tools

Part 1: Claude Code Auto Accept

Claude Code is Anthropic’s command-line AI coding assistant. It offers the most comprehensive auto-accept capabilities through its terminal interface.

Quick Toggle: Shift+Tab (Fastest Method)

The fastest way to enable auto-accept in Claude Code is the Shift+Tab keyboard shortcut, which cycles through three modes:

Normal Mode (default) – Prompts for all operations
Auto-Accept Mode (shows ⏵⏵ accept edits on) – Auto-approves all file edits and operations
Plan Mode (shows ⏸ plan mode on) – Read-only research and planning mode

How to use:

Press Shift+Tab once to enter Auto-Accept Mode
Look for ⏵⏵ accept edits on at the bottom of your terminal
Press Shift+Tab again to cycle to Plan Mode or back to Normal
Switch modes anytime during a session

What Auto-Accept Mode Does

When Auto-Accept Mode is enabled:

File modifications proceed without confirmation
Bash commands run immediately
All operations execute seamlessly
Risk: Potentially destructive operations occur without pause

Best for:

Uninterrupted workflow when you trust Claude’s direction
Repetitive tasks like refactoring
Long agentic sessions (10-40+ minutes)
Bulk modifications across multiple files

Alternative Ways to Enable Auto-Accept

Via command flag:

claude --permissionMode acceptEdits

In settings.json:

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Plan Mode (Read-Only)

Plan Mode is the opposite of Auto-Accept – it restricts Claude to read-only operations:

Code exploration before making changes
Interactive development with iterative planning
Understanding complex codebases
Reviewing plans before execution

Enable via:

Press Shift+Tab twice from Normal Mode
Command: claude --permissionMode plan

Configuration-Based Permissions

For persistent, fine-grained control, configure permissions in .claude/settings.json:

Permission Levels:

allow – Auto-accept without prompting
deny – Block without prompting
ask – Always prompt for approval

Example Configuration:

{
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test:*)",
      "Bash(git log:*)",
      "Bash(git diff:*)",
      "Read"
    ],
    "deny": [
      "Bash(curl:*)",
      "Bash(rm -rf:*)",
      "Bash(sudo:*)",
      "Read(./.env)",
      "WebFetch"
    ],
    "ask": [
      "Bash(git push:*)",
      "Write(./production/**)",
      "Edit"
    ]
  }
}

Pattern Syntax:

ToolName – Matches any use of that tool
ToolName(pattern) – Matches specific patterns
Bash(command:*) – Prefix matching for bash commands
Read(./path/**) – Glob patterns for file paths

Command-Line Flags

Allow specific tools:

claude --allowedTools "Bash(git log:*)" "Bash(git diff:*)" "Read" "Write"

Block specific tools:

claude --disallowedTools "Bash(rm:*)" "Bash(sudo:*)" "WebFetch"

Skip all permissions (use with extreme caution):

claude --dangerously-skip-permissions

Warning: This completely bypasses all safety checks. Use only in trusted, isolated environments.

Settings File Hierarchy

Claude Code uses a tiered settings system (highest priority first):

Managed settings – Enterprise/org policies
Project local settings – .claude/settings.local.json
Project settings – .claude/settings.json
User settings – ~/.claude/settings.json
CLI flags – Override filesystem settings

MCP Tool Permissions

Claude Code supports MCP servers with auto-accept configuration:

{
  "permissions": {
    "allow": [
      "mcp__github__create_issue",
      "mcp__github__list_issues"
    ],
    "deny": [
      "mcp__github__delete_repository"
    ]
  }
}

Note: MCP permissions do NOT support wildcards. List each tool explicitly.

VS Code Extension Limitations

The Claude Code VS Code extension has more limited auto-accept capabilities:

Feature	CLI (Terminal)	VS Code Extension
Shift+Tab Modes	Full support	Not available
–dangerously-skip-permissions	Supported	Not supported
Configuration Files	Full support	Limited
Auto-Accept Edits	Via mode toggle	Built-in toggle
Bypass All Permissions	Possible	Not possible

Recommendation: For full auto-accept control, use the CLI in VS Code’s integrated terminal rather than the extension.

Keyboard Shortcuts Reference

Shortcut	Action
`Shift+Tab`	Toggle modes (Normal → Auto-Accept → Plan)
`Ctrl+C`	Cancel current operation
`Ctrl+D`	Exit Claude Code
`Ctrl+L`	Clear screen
`Esc + Esc`	Edit previous message
`Tab`	Toggle extended thinking

Part 2: Claude Desktop Auto-Approval

Claude Desktop is the standalone app for macOS and Windows. It has simpler auto-approval options focused on MCP tool permissions.

Built-In “Always Approve” Button (Easiest Method)

Status: Built into Claude Desktop as of May 2025

Claude Desktop now includes a built-in “Always approve” button directly in the tool permission dialog. This is the easiest way to enable auto-approval for trusted MCP tools.

How to use:

When Claude requests permission to use a tool, look for the “Always approve” button
Click “Always approve” for tools you trust
That tool will be automatically approved in future sessions

What it does:

Creates permanent approval for the selected tool
Works automatically across all chats
No additional setup required

To revoke approval: Rename the MCP server in your claude_desktop_config.json file (e.g., change git to git_new), which resets permissions for that server.

Alternative: Per-Chat Approval with MCP Server

For more granular control with per-chat approvals (rather than permanent), there’s a third-party MCP server solution.

The claude_autoapprove_mcp server offers:

“Allow for this chat” functionality
Configurable autoapprove and autoblock lists per MCP server
Ability to change decisions in future chats

Important: We haven’t reviewed this solution ourselves. Use at your own discretion.

More information: claude_autoapprove_mcp on GitHub

Basic setup:

{
  "mcpServers": {
    "claude-autoapprove-mcp": {
      "command": "uvx",
      "args": ["claude-autoapprove-mcp"]
    },
    "your-mcp-server": {
      "command": "npx",
      "args": ["your-server"],
      "autoapprove": ["read_file", "search_files"],
      "autoblock": ["write_file"]
    }
  }
}

Choosing the Right Model for Auto-Accept

When using auto-accept features, model selection becomes critical since you’re giving Claude more autonomy.

Claude Sonnet 4.5 (Recommended)

Best for: General use, tool calling, and auto-accept workflows

Excellent at maintaining conversation context
Reliably remembers details from earlier in the session
Superior understanding of implicit context when calling tools
Handles complex multi-step operations well

Claude Haiku 4.5

Best for: Fast, focused tasks with explicit instructions

Very fast performance
Cost-effective for high-volume operations
Requires stricter, more explicit instructions
May lose track of conversation context

Model Selection by Scenario

Scenario	Model	Why
Auto-Accept Mode coding	Sonnet 4.5	Context awareness crucial
Plan Mode exploration	Sonnet 4.5	Complex reasoning needed
MCP tool chains	Sonnet 4.5	Multi-step context retention
Simple file operations	Haiku 4.5	Speed matters, context simple
Batch processing	Haiku 4.5	Repetitive, explicit tasks

Switch models in Claude Code:

/model sonnet
/model haiku

Security Best Practices

Always review auto-accepted tools periodically
Never auto-accept tools that can delete or modify production systems
Use isolated environments (VMs, containers) when testing
Keep auto-accept lists minimal and specific
Monitor tool usage through console logs
Consider using hooks for additional validation

Troubleshooting

Claude Code Issues

Auto-Accept not working: Check the terminal bottom for mode indicator (⏵⏵ accept edits on)
Repeated approval prompts: Configure allowedTools in settings or use CLI flags
Permissions not applying: Check settings file hierarchy and precedence
Stuck in Plan Mode: Press Shift+Tab to cycle back to Normal Mode
VS Code extension still prompting: This is expected – use CLI for full control

Claude Desktop Issues

Want to revoke “Always approve”: Rename the MCP server in claude_desktop_config.json
Tools not auto-approving: Verify you clicked “Always approve” in the permission dialog
MCP server issues: Restart Claude Desktop after config changes

Resources

Official Documentation:

Community Resources:

Claude AutoApprove MCP Server (third-party)

Summary

Claude Code: Press Shift+Tab to toggle auto-accept mode. For persistent settings, configure permissions in .claude/settings.json or use CLI flags like --allowedTools.

Claude Desktop: Click the “Always approve” button in the tool permission dialog for permanent approval of trusted MCP tools.

Choose Sonnet 4.5 for auto-accept workflows due to its superior context awareness. Start with the most restrictive settings and gradually expand as you gain confidence.

Remember: Auto-accept is powerful, but responsibility for the outcomes rests with you.

Author

Scott Dooley

Scott has been coding websites since before "mobile responsive" was a thing. After a stint working as a growth marketer in London, he switched to the "digital nomad" life and now leads a team of talented developers, designers and marketers at Kahunam.