"It keeps asking for permission." It is the Claude Code complaint I run into most, usually with a sequel: I clicked always allow, I even turned on --dangerously-skip-permissions, and it still asks.
So I measured it instead of guessing. Two tasks, seven setups, seven runs per combination, three extra runs for one separate check, and every permission prompt logged. How often it asks depends less on how much the agent does than on how it bundles the work and which paths it touches. A low count can even mean you reviewed less.
Where you start these days
First the change most explanations still miss. Since version 2.1.283, auto mode is the mode a new terminal or VS Code session starts in. The permission modes docs say so plainly: a second model, the classifier, reviews actions instead of you. My own permissions guide still called Manual the starting point, and gained a correction alongside this post.
If Claude Code keeps asking you, you are probably not in auto. You picked another mode yourself, your organisation turned auto off, or you are hitting one of the cases that ask in every mode. That last group is the interesting one, and I will get to it.
How I counted
A small Node repo as the test subject, with two tasks:
- Task A: fix a broken
slugify, add amaxLengthoption with tests, run the suite and commit. - Task B: prepare a release. A CLI in
bin/, a GitHub Actions workflow, a.husky/pre-commithook, a changelog entry, a commit andnpm version patch.
Every run was claude -p on Claude Code 2.1.326 with Opus 5.5, in a clean config directory without my own hooks, plugins or rules. Permission prompts went through --permission-prompt-tool to a tiny MCP tool that logs each request and says yes.
Every line in that log is a click you would have made, and the run carries on as if you had. The folder counted as trusted, as it does for you once you have dismissed the trust dialog.
All 101 runs finished their task: green tests, a commit, and for task B the right tag. Having the same slugify fixed more than fifty times mostly produces the best-tested slugify function in Europe.
| Setup | Task A: fix + feature | Task B: release | What kept asking |
|---|---|---|---|
| manual | 4 (4–5) | 3 (2–8) | nearly every edit and shell command |
| acceptEdits | 2 (2–3) | 3 (2–4) | shell commands, and for edits only .husky/pre-commit |
| plan | 4 (4–5) | 5 (3–12) | the plan, its own questions to you, then edits |
| auto | 0 | 0 | nothing |
| manual + 8 allow rules | 2 (2–3) | 3 (2–8) | file writes, mkdir, npm version patch |
| manual + sandbox auto-allow | 3 (2–3) | 1 (1–2) | Write and Edit, shell writes, and on B the one command with every release file |
| bypassPermissions | 0 | 0 | nothing |
Median per run, with the range over seven runs in brackets. One caveat on plan: without a terminal, an approved plan continues in Manual here. Interactively you can pick "Yes, and use auto mode", which I did not measure.
Fewer prompts is not more oversight
The most telling number is missing from the table. In six of the seven Manual runs of task B, the agent wrote nearly the whole release in a single shell command: a row of heredocs and redirects, one after another. One prompt, one yes, and 5 or 6 files were on disk. Each of those six runs wrote the git hook in .husky/pre-commit, the script that now runs on every commit.
That is also why task B cost fewer prompts in Manual than the smaller task A. The agent did more and bundled it better.
If you treat the prompt count as a measure of oversight, you reward exactly that behaviour: the more fits in one command, the less you get to see. Nobody reads a seventy-line heredoc in a permission prompt. You click it away.
What acceptEdits does not cover
acceptEdits is the standard advice against prompt fatigue, and it does halve the prompts on task A. But it only approves edits made through the file tools, plus a short list of common commands such as mkdir and mv. When the agent writes a file through the shell, that is a shell command, and it asks. On task A every prompt left in acceptEdits was a Bash command, including tests appended to a test file with cat >>.
The sandbox in auto-allow covers a different piece. It lets most shell commands run free when they stay inside the sandbox, but it has no say over the Write and Edit tools, so those still ask.
Writing through the shell sometimes asked in the sandbox too: on task A in four of the seven runs. On task B the whole release mostly cost a single prompt there, and each time it was the one big shell command that wrote every file, .husky included. How to combine the two is in the sandboxing guide.
Three traps you do not hear coming
A repo's allowlist does nothing in a folder nobody trusted. With the folder untrusted, the allowlist gave 4 prompts, exactly as many as Manual with no rules at all, and with the folder trusted it dropped to 2. According to the docs on workspace trust, Claude Code applies permissions.allow from .claude/settings.json only after someone accepts the trust dialog for that folder. claude -p never shows that dialog.
What that means for a team is in the post on sharing your config. For CI it means a committed allowlist approves nothing, unless the job marks the folder trusted itself with hasTrustDialogAccepted in ~/.claude.json. Deny and ask rules do apply straight away, since they only restrict.
Protected paths ignore your allow rules. My first full round of 35 runs mostly measured the folder I keep my notes in. The test repo lived under ~/.claude, and acceptEdits asked more often in total than Manual there. .claude is on the list of protected directories, along with .git, .vscode and .husky, among others.
Writes there prompt in Manual and acceptEdits, even when an allow rule covers them. The same rule produced the only edit prompts acceptEdits had on task B: all three for .husky/pre-commit.
An ask rule beats bypass. With bypassPermissions and a single ask rule for git commit, Claude Code asked about that commit in three runs out of three, and about nothing else. The docs list more exceptions of this kind that no mode skips. If it still asks while --dangerously-skip-permissions is on, look for an ask rule in your settings first.
What I would do
- Check which mode you are in. If the prompts come in Manual or plan, switching to auto is the biggest single step: from four to zero in my runs. You trade your judgement for a classifier's, and I have measured what that costs before.
- If you do not want a classifier, use acceptEdits with allow rules for your regular commands. Put them in a file that actually gets read: your user settings, or the project folder once you have trusted it.
- Send shell work through the sandbox. It catches most of what acceptEdits leaves behind. Writing through the shell still asked now and then in my runs.
- Read the prompt you approve, especially the long one. A command with five redirects is five files, and one of them can be a hook that runs on every commit.
This is one small repo with two tasks, run without a terminal. A real working day has more kinds of commands, and "always allow" builds up a list over days that these runs never had. The direction holds: the prompt count measures how the agent packs its work, and says little about how much of it you saw.