Claude Code Permissions: Safe vs Fast Development Modes

Problem: Claude Code constantly asking for permission to edit files, run commands, or make changes disrupts your development flow and kills productivity.

Quick Win: Switch to auto-accept mode for trusted tasks by pressing Shift+Tab until you see "auto-accept edit on" in the UI:

# Current modes cycle through:
normal-mode → auto-accept edit on → plan mode on

Understanding: Claude Code has three permission levels designed for different development scenarios. Knowing when to use each one transforms your coding workflow from constant interruptions to smooth automation.

The Three Permission Modes

Claude Code gives you three distinct permission modes, each optimized for specific development scenarios.

Normal Mode (Default Security)

Normal mode prompts for every potentially dangerous operation. You'll see confirmation dialogs for:

• File edits and modifications
• Terminal command execution
• System operations
• Directory changes

This mode prioritizes security over speed, making it perfect for:

• Working on production code
• Unfamiliar codebases
• Learning new techniques
• High-risk operations

Auto-Accept Mode (Productivity Flow)

Auto-accept mode eliminates permission prompts for configured tools, enabling uninterrupted execution. Claude proceeds immediately with approved operations.

Activate by pressing Shift+Tab until you see "auto-accept edit on" in the interface.

Best for:

• Large refactoring sessions
• Following well-defined implementation plans
• Research and documentation tasks
• Repetitive operations across multiple files

// Configure which tools auto-accept in ~/.claude.json
{
  "allowedTools": [
    "Read(*)",
    "Grep(*)", 
    "Edit(*)",
    "Bash(npm install *)"
  ]
}

Plan Mode (Read-Only Research)

Plan mode restricts Claude to read-only operations, preventing any modifications while allowing comprehensive analysis.

Perfect for:

• Initial codebase exploration
• Architecture analysis
• Planning complex features
• Code review sessions

Smart Permission Configuration

Instead of using the dangerous --dangerously-skip-permissions flag that removes ALL safety checks, configure specific tool permissions through your ~/.claude.json file.

Granular Control Example

{
  "allowedTools": [
    "Read(*)",           // Safe: Only reading files
    "Grep(*)",          // Safe: Only searching content
    "Edit(src/*)",      // Limited: Only edit source files
    "Bash(npm *)",      // Limited: Only npm commands
    "Write(docs/*)"     // Limited: Only documentation files
  ]
}

This approach gives you automation where you want it while maintaining safety barriers for sensitive operations.

Development Scenario Strategies

Early Development (Use Normal Mode)

When starting new projects or exploring unfamiliar code:

• Keep all permissions manual
• Review each suggested change
• Learn how Claude approaches problems
• Build confidence in the AI's decisions

Active Development (Use Auto-Accept)

During intensive coding sessions:

• Configure auto-accept for trusted file types
• Allow common commands (npm, git status)
• Maintain prompts for system operations
• Enable uninterrupted workflow

Code Review (Use Plan Mode)

When analyzing existing codebases:

• Switch to plan mode for safety
• Let Claude explore without modifications
• Generate analysis and recommendations
• Switch modes only when ready to implement

Common Permission Pitfalls

Over-permissioning: Don't use --dangerously-skip-permissions flag. This removes ALL safety checks and can destroy your environment.

Under-permissioning: Constantly clicking "Allow" defeats the purpose. Configure repeat operations in allowedTools instead.

Mode Confusion: Check your current mode before starting work to avoid unexpected behavior.

Blanket Permissions: Avoid allowedTools: ["*"] patterns. Be specific about which tools Claude can access.

Security Best Practices

Configure permissions based on the principle of least privilege:

{
  "allowedTools": [
    "Read(src/*, docs/*, README.md)",
    "Grep(src/*, tests/*)",
    "Edit(src/components/*)",
    "Write(docs/api/*)"
  ]
}

This allows reading source files, searching code/tests, editing components, and writing documentation.

Success Verification: Test with a simple task. You should see smooth execution for allowed operations and prompts for restricted ones.

What's Next

Master your development workflow by learning complementary techniques:

• Optimize your feedback loops for faster iteration
• Set up efficient todo workflows for task management
• Configure git integration for seamless version control
• Explore configuration basics for advanced setup options
• Learn about troubleshooting common permission issues

Remember: Permission modes are tools for different development phases. Normal mode for safety, auto-accept for productivity, plan mode for exploration. Match the mode to your current needs, not your preferences.