I was in the middle of a production release — squash-merging 33 commits, pushing to three remotes, monitoring Slack channels for user reports — when Claude Code asked me for the fourteenth time whether it could run gcloud logging read. I had already approved it. Multiple times. In the same session.
Each approval pulled me away from the release. Read the command, decide whether it was safe, approve it, recover my place. Then another git log, another grep, another Slack channel read. The tool helping me work faster kept interrupting the work. The default behavior that protected new users was punishing experienced ones.
Changing the configuration reduced those interruptions in my workflow. I wanted routine work I had already authorized to proceed without another round of dialogs. I favor deliberate broad shell access for experienced practitioners doing development work.
Current documentation checked September 28, 2026. The settings guidance and constructed workbook below supplement the March and April experience.
Start with the work and the settings that apply
The workbook isolates permission mechanics with a deliberately narrow task: running an already reviewed build in a local repository called workbook-app. Its dependencies are present, its build script needs no remote service, and the task authorizes neither deployment nor messaging. That gives the permission policy a concrete job: allow that build and make any expansion of the task apparent.
| Scope | Location | Purpose |
|---|---|---|
| User | ~/.claude/settings.json | Personal defaults across projects |
| Shared project | .claude/settings.json | Settings reviewed with the repository |
| Project local | .claude/settings.local.json | Personal choices for this project |
| Managed | Organization-managed file or policy | Administrative settings |
For ordinary scalar settings, precedence runs managed, command line, project local, shared project, user, highest first. Permission lists merge across loaded files. A narrow local allow list therefore does not remove a broad user allowance. These are separate from rule evaluation: a matching deny takes priority over ask, and ask over allow. Settings files and precedence, permission rules.
This matters when a team chooses a starting mode. A user-level dontAsk value does not override the shared project's default value in a terminal session. A project-local value can override that shared value, subject to higher settings. An allowed command still cannot override an effective deny from another scope.
Inspect /status for loaded settings sources and /permissions for rules and their source files. The first is a file inventory, not a per-key explanation. If you create a local settings file manually, arrange its Git exclusion; do not assume the filename alone makes it ignored. Keep credentials out of committed settings. Settings inspection and local files.
The eighty-pattern experiment
My first approach was to approve commands by category. The list looked deliberate:
{
"permissions": {
"allow": [
"Bash(git:*)", "Bash(gh:*)", "Bash(gcloud:*)",
"Bash(node:*)", "Bash(npm:*)", "Bash(python:*)",
"Bash(ls:*)", "Bash(grep:*)", "Bash(find:*)",
"Bash(curl:*)", "Bash(jq:*)"
]
}
}
I built templates with 80-plus patterns, from Bash(tar:*) to Bash(dig:*), and spent a week trying colons, spaces and wildcards. Compound commands kept appearing in the work:
cd /path/to/repo && git fetch origin && git log --oneline HEAD..origin/main | head -5
The chain changes directory, fetches, inspects the incoming history and limits the display. Those are useful related operations to review together. My April 9 update reported continued prompts during that experiment and replaced the granular approach with a broad allowance.
Current documentation says Claude Code recognizes compound-command operators and checks subcommands separately; a directory change can also require path permission. A prompt on this chain does not establish that Claude treated it as one opaque string. Inspect the installed version, effective rules and path permissions to identify which check caused a prompt. Compound-command handling.
A program name can cover much more than the task being authorized. gcloud can read logs and change infrastructure. A Python script can calculate a result or call an external API.
What the broad recipe granted
This was the core of the broad shell configuration I recommended after the eighty-pattern experiment. It replaced command-by-command bookkeeping with a deliberate grant of shell access:
{
"permissions": {
"defaultMode": "dontAsk",
"allow": [
"Read(*)", "Write(*)", "Edit(*)",
"Bash(*)",
"WebFetch(*)", "WebSearch(*)"
],
"deny": [
"Bash(rm -rf /)",
"Bash(rm -rf ~)",
"Bash(rm -rf /*)"
]
}
}
This removed the compound-command interruptions in my work. It also permitted far more shell activity than the log reads that had frustrated me. Three removal patterns do not describe the boundaries of a cloud account, a database or a messaging service. A mistaken deployment or message does not become recoverable because the repository has Git history.
Current documentation also cautions that command-text rules do not contain every way to invoke a program. A blocked spelling and a blocked effect are different things to verify. The product has additional critical-path protections, but those do not turn this historical recipe into a complete policy for remote changes. Bash rule limits, critical-path protections.
The published gist contains both examples I shared: a global file using dontAsk with my MCP allowances, and a project file using acceptEdits. Both include the broad shell rule and three removal patterns.
For my development work, I favor that deliberate breadth. Once we have agreed on the work, I want the agent to inspect the repository, change code, run tests and repair failures without negotiating every shell command. Production deployment and sending messages remain separate decisions, even when the shell can perform them. A broad allowance records my choice to grant capability; credentials and environment controls can add technical restrictions where the work requires them. The workbook uses a narrower task to make the permission mechanics visible.
Choose what happens when a call needs approval
My April 13 update added dontAsk, a six-mode comparison and the settings-drift account. For this local-build example, the useful choice is what to do when an ordinary call still needs approval:
| Explicit terminal mode | Choice for this task |
|---|---|
default (Manual) | Ask about an unapproved action while honoring applicable allow rules |
acceptEdits | Also permit documented edits and common filesystem operations within their defined scope |
dontAsk | Deny calls that would otherwise ask |
dontAsk does not mean only names in your allow list can run: built-in actions that need no approval can still run. It also denies interaction-dependent tools, including AskUserQuestion. That can remove a permission interruption while leaving work unfinished because the agent needed an answer. The current mode documentation covers plan, auto and bypassPermissions and their exceptions; the examples here explicitly use terminal default or dontAsk. Interfaces differ, so do not assume a VS Code or cloud session applies the same starting-mode settings. Permission modes.
For a known build, rejection may be the right response to an unexpected action. While exploring an unfamiliar project, I may want to inspect and approve a newly required step.
A personal build policy and a shared one
The first illustration requests dontAsk for the local project and allows one command. The workbook calls this file personal-project.json so extracting it cannot make it an active Claude settings file. When deliberately adopting a project-local policy, its destination would be .claude/settings.local.json.
{
"permissions": {
"defaultMode": "dontAsk",
"allow": [
"Bash(npm run build)"
]
},
"sandbox": {
"enabled": true,
"autoAllowBashIfSandboxed": false,
"allowUnsandboxedCommands": false,
"failIfUnavailable": true
}
}
Before approving npm run build, inspect the actual package.json script and what it invokes. The same command text in another repository can execute a different program. The allowance has no understanding of that review, and the workbook does not perform it for you. npm script behavior.
For a shared project, this second illustration retains the same build allowance and sandbox requests, with default so that ordinary unmatched calls can ask. The repository file would be .claude/settings.json; the download names it shared-project.json.
{
"permissions": {
"defaultMode": "default",
"allow": [
"Bash(npm run build)"
]
},
"sandbox": {
"enabled": true,
"autoAllowBashIfSandboxed": false,
"allowUnsandboxedCommands": false,
"failIfUnavailable": true
}
}
These are complete illustrative files for the stated task, not records of my installed configuration. They contain no personal MCP integrations. Teammates can discuss the shared build task without inheriting one person's browser or messaging permissions. Personal integrations need their own review, wherever their settings live.
Both examples request a Bash sandbox, turn off its automatic command approval, disallow unsandboxed retries and request a hard failure if it cannot initialize. The sandbox restricts covered shell processes; it is separate from a permission mode and does not enclose every file tool, MCP server or browser action. Its actual filesystem, network and credential access depend on the resolved configuration. Merely enabling it does not supply a secret-free environment. Bash sandbox configuration.
This illustration requires a supported sandbox environment, such as macOS, Linux or WSL2. Inspect the resolved /sandbox settings before adoption. Existing exclusions, additional directories, network allowances or managed values may change the result. A denied build is a useful signal to inspect those conditions, not a reason to grant arbitrary shell access.
Reading a channel does not authorize sending a message
My original settings distinguished Slack reads from sends. They named operations such as mcp__slack__slack_read_channel, mcp__slack__slack_read_thread and mcp__slack__slack_search_public. Those were connector-specific names in that account, not a promise about the names your installation exposes.
In the workflow I described, messages carried a “sent using Claude” label, and I could not edit or delete them through the available workflow. That made sending in my name a consequential boundary. Slack's API does support certain message updates and deletions, subject to authorship, token and message-type restrictions; that does not establish that my historical connector exposed those operations. Slack's message modification documentation.
My template also listed mcp__plugin_playwright_playwright__* and mcp__claude_ai_Hugging_Face__*. An MCP server-wide wildcard does not mean read-only; inspect the operations it includes. MCP rule matching.
| Route | What must be examined |
|---|---|
| An MCP send tool | Whether that tool is exposed and approved |
| A shell client | Whether shell access, credentials and network access permit the request |
| A browser form | Whether the browser can submit using a signed-in session |
Omitting the first tool from an allow list leaves the other routes as separate questions. A task to build locally authorizes none of these sends. The same distinction applies to production deployment: a broad shell rule may match its command, while the user has authorized only build preparation.
I want the task, the credentials and the available tools to agree on that boundary. For release preparation, use an environment that lacks production write access unless the task calls for it. Record an explicit deployment decision before making the external change. An instruction to wait is useful, but it should not be mistaken for proof that every available route is blocked.
The 226 entries, and the prompts that came back
The permission list I found in one project contained 226 one-off entries: specific psql paths, wrangler commands with embedded API tokens, and gcloud subcommands with full query strings. The shorter examples convey the shape of the accumulation without publishing any token:
Bash(gcloud run services describe:*)
Bash(gcloud secrets list:*)
Bash(gcloud config get-value:*)
Bash(gcloud sql instances list:*)
Bash(gcloud logging read 'resource.type="cloud_run_revision" AND ...)
These are historical entry examples, including an abbreviated log filter, not a current list to install. Each recorded a decision made while I was trying to finish other work. I replaced that file with the broad allowance and three deny rules in five minutes.
Two weeks after switching to a clean six-line allow list, I found 130-plus granular entries again. Bash(git *), Bash(grep *), Bash(find *), Bash(curl *): familiar entries, familiar interruptions. The prompts were back, and I had resumed approving commands without noticing how the file was changing.
To diagnose a recurrence like this, compare the installed version and before-and-after effective settings. Redundant entries alongside a broad rule do not by themselves explain new prompts.
Inspect the change behind the prompt
- Inspect an unexpected prompt. Record the exact tool call, active mode and relevant rule sources. Check for an unmatched command, a matching ask or deny, a path restriction, or a setting that did not load. Compare the relevant files before attributing the cause.
- Review saved approvals every week. A persistent allowance is a configuration change. Decide whether the repeated operation belongs in the task policy instead of treating every approval as harmless housekeeping. A useful allow list can contain more than fifteen entries.
- Version-control a sanitized policy. Keep secrets out of it and review the diff. Restoring an old file is appropriate only if its permissions still fit the present task. A token accidentally stored in a shareable file needs credential remediation, not just cosmetic pruning.
The same review belongs at the start of a new project, after adding an MCP server, when changing which action should ask or be denied, and after a product update changes the relevant behavior. A new server deserves tool-by-tool inspection before it receives a wildcard.
I want configuration maintenance to replace prompt-by-prompt negotiation. A growing file of one-off approvals keeps asking me to solve the same design problem while I am trying to finish the task. Choose the scope deliberately, review changes to it, and keep routine authorized work moving.
Work through the permission workbook
The downloadable permission workbook contains fifteen constructed cases, the two settings illustrations, completed answers and an offline checker. Each case specifies its assumptions. The questions separate the listed permission result, task authorization, evidence about prompt causation and the native result.
For example, an exact allowance can match npm run build in both the intended repository and an unapproved one. The task authorizes only the first. A deny from another scope changes the documented rule result even when the task itself is authorized. In another case, a shell rule matches a hypothetical message-sending script while the build task authorizes no send. These comparisons expose a policy decision that a list of tool names can hide.
From the extracted workbook directory:
python3 -B check_workbook.py answers.json
python3 -B test_workbook.py
python3 -B fault_checks.py
The eight documented commands produced their expected exits from both source and a clean archive extraction. The completed workbook matched 60 categorical expectations across fifteen cases. Its 27 checks reject four one-field wrong-answer controls, malformed input and changed settings illustrations; five deliberately faulty checker variants fail the unchanged tests. The README also gives the individual negative commands and their expected nonzero exits.
Every native result stays UNKNOWN, and explanations still need review: the suite deliberately shows that a false explanation can accompany mechanically correct categorical answers. No connector, shell client, browser send or deployment described in the cases was executed.
If you want to validate your installed client, the README gives a separate procedure for a harmless build in a disposable project, with the exact version, effective settings and observed call recorded. That native procedure was not run for this package.
At the next repeated prompt, compare the actual call with the work and authority you agreed on. If routine development is already covered, repair the rule or environment condition causing the interruption. If the call expands into messaging, another repository or a deployment you have not authorized, make that decision explicitly.
The goal is to eliminate interruptions that add no safety. Operations with consequences beyond the agreed work should still make us pause; the authorized work should flow.