Try free

Last updated 13 October 2026

Changing Claude Code permission levels

Managing the friction of tool approvals

You are trying to ship code but the terminal keeps asking for permission every time the agent wants to run a simple grep command or read a file. This constant context switching breaks your focus and turns a fast automation tool into a slow manual oversight process. You want the agent to handle the boring parts without stopping to ask you for every minor detail, but you also do not want it to delete your database or overwrite sensitive configuration files by mistake. Finding a balance is difficult when you are working across different environments with varying levels of risk.

The right balance between security and speed depends on the specific project and how much you trust the current environment. Claude Code provides several built-in mechanisms to adjust these permission levels so you can move from a high-friction manual mode to a more automated workflow. You can change these settings globally, for a specific project, or even just for the current interactive session depending on what you need at that moment. Understanding how to toggle these levels will help you maintain your flow state while keeping your system safe from unintended side effects.

Choosing the right permission mode

The primary way to change how the agent asks for permission is through the four built-in modes. You can cycle through these modes inside an active session by pressing Shift+Tab. Each mode changes the threshold for what requires a manual confirmation from you. The default mode is the most restrictive and safest for new projects where you want to see exactly what Bash commands are running or what files are being modified before any changes happen on your disk. This mode is excellent for learning how the agent thinks and ensuring its logic matches your expectations.

If you want to move faster but still want to review code changes, you can switch to the acceptEdits mode. In this mode, the agent still asks you before running shell commands but it will go ahead and perform file edits automatically. This is useful when you are doing a large refactor across many files and you trust the agent to update the imports and syntax correctly. If you need to stop the agent during this process, you can press the Escape key once to interrupt the current action. This gives you a safety valve while removing the need to click okay for every individual file edit.

Using plan and bypassPermissions for speed

The plan mode focuses on the agent's internal reasoning and tool use without executing the final destructive actions immediately. It allows you to see the logic and the sequence of steps before any execution occurs. However, the most permissive setting available is bypassPermissions. When you enable this, the agent will execute all tools including Bash and Write without asking for your approval. This is the fastest way to work but carries the most risk because the agent could potentially run a command that deletes data or sends sensitive information to an external endpoint through WebFetch. You should use this mode with caution.

You should only use bypassPermissions in a sandbox or a version-controlled environment where you can easily revert changes using your shell history or git commands. If the agent starts doing something unexpected while in this mode, press Escape twice to see the history of messages and go back to a safe point. You can also quit the session entirely by pressing Ctrl+C. Most developers find that switching back to the default mode after a heavy task is the safest way to maintain control over their system. This mode is best reserved for trusted projects with high test coverage.

Configuring persistent tool permissions

Changing modes with Shift+Tab only lasts for the current session. To make your permission preferences permanent, you need to edit the settings files. Claude Code looks for a file named settings.json inside the .claude directory of your project root. If you want a setting to apply to every project on your computer, you should edit the settings.json file located in your home directory at ~/.claude/settings.json instead. This allows you to create a global profile for tools you always trust. Using the /config command inside a session can also help you view or update these values.

Inside the settings.json file, you can define a permissions object to control individual tools like Bash, Read, or Write. For example, you might decide that the Read tool should never require a prompt because looking at files is generally safe. You can set the permission for specific tools to be allowed automatically while keeping tools like Bash on a manual approval list. This granular control means you can build a custom security profile that fits your specific workflow and risk tolerance without changing the mode for every single session you start.

Handling local overrides and project instructions

Sometimes you work on a team project where the standard .claude/settings.json is tracked in git. You might want different permission levels than your teammates without affecting the main repository. In this case, you can create a file named .claude/settings.local.json. This file is for your own personal overrides and should be ignored by your version control system. It allows you to set more permissive or more restrictive rules that only apply to your local machine for that specific project. This is the best place for experimental permission settings.

You can also use the CLAUDE.md file to give the agent specific instructions on how it should handle its tasks. While CLAUDE.md does not technically change the binary permission levels of the tools, it provides the context the agent needs to act responsibly. If you put a CLAUDE.md file in the root of your repo, the agent will read those instructions at the start of the session. You can use this file to tell the agent to always use the Grep tool before attempting a Write tool action, which helps it gather more context and make fewer mistakes even when permissions are more automated.

Managing multiple sessions and complex workflows

As you start using Claude Code for more complex tasks, you might find yourself needing different permission levels for different parts of the same project. You might want one session to have full bypassPermissions for a heavy refactor while another session stays in default mode for testing. Manually managing several terminal windows with different flags and modes can become disorganized and lead to mistakes where you run a dangerous command in the wrong window. This lack of visual clarity can lead to accidental data loss or security breaches.

This is where adhdTerminal becomes a useful tool for a developer's workflow. It allows you to run many Claude Code sessions side by side on a single wall of tiles. Each tile has a colour, a number and a name, showing whether it is working, waiting for you, done or idle. Because each tile preserves its state and location, you can keep a high-permission session running in one tile for your heavy lifting while keeping a restricted session in another tile for careful configuration work. This visual organization helps you track which environment has which level of autonomy without mixing them up.

Monitoring costs and tool usage

Changing permission levels to be more automated can lead to a higher volume of tool calls in a shorter amount of time. Each time the agent uses a tool or processes a file, it consumes tokens that contribute to your overall spend. When you are in a mode like bypassPermissions, the agent might loop through many tasks without you noticing the cumulative cost. It is a good practice to check your current spending frequently when you are running highly automated sessions. You should be aware of how much each task costs to avoid surprises on your bill.

You can use the /cost and /usage commands inside any session to see how much you have spent. If you find that a session is becoming too large and expensive because of a long conversation history, you can use the /compact command. This summarises the session so far and frees up space in the context window, which can help lower the cost of subsequent tool calls. If you want to start fresh without the previous history but in the same folder, use the /clear command to reset the session while keeping your current permission settings and active mode.

Working with subagents and MCP servers

Claude Code can spawn subagents to handle specific subtasks by using markdown files located in .claude/agents. These subagents operate under the permission umbrella of the main session. If you have configured custom slash commands in the .claude/commands directory, those commands also follow the permission rules you have set in your settings files. You can also extend the capabilities of the agent by managing MCP servers with the "claude mcp" command or the /mcp slash command inside a session. Permissions for these external servers must be managed carefully to protect your local environment.

Permissions for MCP servers are configured in the .mcp.json file. When the agent attempts to use a tool provided by an MCP server, it will still respect the overall permission mode of the session. If you are using the adhdTerminal iPhone app, you can monitor these tool calls and permissions remotely over an end to end encrypted link. This allows you to approve a task or send the next prompt even when you are away from your desk. This mobile mirror ensures that your automated workflows keep moving safely without sacrificing the security of a manual check when the agent requests it.

Verifying and updating your installation

If you find that your permission settings are not behaving as expected, you should check the health of your installation. Running the "claude doctor" command from your shell or using the /doctor command inside a session will check for common configuration issues. This tool can identify if your settings.json files have syntax errors or if the agent does not have the necessary system permissions to execute certain Bash commands. It is a vital first step for troubleshooting any unexpected behavior in tool execution or permission prompts.

Keeping the tool updated is also important for security and stability. You can run "claude update" to ensure you have the latest version of the coding agent. Since permissions and tool safety are frequently refined, staying current helps ensure that the bypassPermissions and acceptEdits modes function reliably. If you ever need a quick reminder of the available commands or how to structure your settings, the /help command provides a list of internal tools and commands to guide you through the configuration process. Regular updates help you take advantage of the most recent safety features.

Questions people ask

How do I revert a change made in bypassPermissions mode?

You can use your shell history with Ctrl+R to find previous commands or use git commands to undo file changes. Inside the session, you can also press Escape twice to go back to an earlier message state before the command was run. This is why it is best to use this mode in a git-tracked directory.

Can I allow specific tools while keeping others restricted?

Yes, you can define specific tool permissions in your .claude/settings.json file. For example, you can set the Read tool to be allowed automatically while requiring manual approval for the Bash tool. This granular control allows you to customize the security level for every individual tool the agent uses.

Where should I put my private permission overrides?

Use the .claude/settings.local.json file in your project directory for local overrides that you do not want to commit to version control. This file takes precedence over the standard settings.json in the same folder. It is the ideal place for settings that are specific to your local machine or personal preferences.

Read next

More on claude code basics·All posts