You said “add a new billing API endpoint.” Claude Code came back with: “Should I use TypeScript or JavaScript? Where would you like the file? Do you want me to add tests? What’s your preferred error format? REST or GraphQL?” Every answer is obvious from the codebase. Or worse: Claude knows what to do but pauses on every single file edit and shell command — Allow Claude to edit route.ts? (y/n) — and the session is 90 percent keypresses.
Fastest fix (each kind of asking is a separate problem):
- It pauses to ask permission before every edit or command → press
Shift+Tabto switch into⏵⏵ accept edits onmode (auto-approves edits + common filesystem commands). For a long task, cycle once more intoautomode (Claude Code v2.1.83+), which runs everything behind a background safety classifier. - It asks you to make decisions (“which framework?”, “where does this file go?”) → write the answers into
CLAUDE.mdas explicit defaults, point the prompt at one canonical example file, and turn on the Proactive output style so Claude makes reasonable assumptions instead of pausing.
The rest of this page is the durable version of both fixes. The trick is telling the two kinds of “asking” apart, because the levers are completely different.
First, which kind of asking is this?
| What you see | Kind | Primary lever |
|---|---|---|
Do you want to make this edit? (y/n) on every file | Permission prompt | Permission mode (Shift+Tab) or permissions.allow |
Allow Claude to run \npm test`? (y/n)` | Permission prompt | Permission mode or an allow rule |
| ”Should I use TypeScript or JavaScript?” | Decision question | CLAUDE.md defaults + Proactive style |
| ”Where should this file live?” | Decision question | Canonical example in prompt; CLAUDE.md |
”I see both findUser and getUser — which?” | Decision question (real) | Resolve repo inconsistency; declare canonical |
| A numbered plan asking “approve this plan?” | Plan mode | Exit plan mode (Shift+Tab) |
Permission prompts are about running tools. Decision questions are about making choices. If you only fix one and the other keeps firing, you will think nothing changed.
Permission prompts: the mode is the fix
Claude Code asks before each edit, shell command, or network request because the default mode (default) auto-approves reads only. As of June 2026 there are six modes. Switch with Shift+Tab during a session — the current mode shows in the status bar.
| Mode | Runs without asking | Use it for |
|---|---|---|
default | Reads only | Sensitive work, getting started |
acceptEdits | Reads + file edits + mkdir/touch/rm/mv/cp/sed in the working dir | Iterating on code you’ll review after |
plan | Reads only (and won’t edit at all) | Exploring before changing |
auto | Everything, behind a background classifier | Long tasks, prompt fatigue |
dontAsk | Only pre-approved tools (everything else denied) | Locked-down CI |
bypassPermissions | Everything, no checks | Isolated containers/VMs only |
Shift+Tab cycles default → acceptEdits → plan. auto slots in after plan once your account qualifies; dontAsk and bypassPermissions only appear when you start with a flag.
The everyday answer: accept-edits mode
Press Shift+Tab once from default. The status bar reads ⏵⏵ accept edits on. Claude now creates and edits files in your working directory without asking, and auto-approves the common filesystem Bash commands (mkdir, touch, rm, rmdir, mv, cp, sed). Anything outside the working directory, any write to a protected path (.git, .env-style files, .claude, etc.), and all other Bash commands still prompt. Review the result with git diff afterward.
To start every session there, set it in .claude/settings.json:
{
"permissions": {
"defaultMode": "acceptEdits"
}
}Long autonomous runs: auto mode
For a task where you trust the direction and don’t want to babysit, cycle to auto (requires Claude Code v2.1.83+ and a recent model; on the Anthropic API, Opus 4.6 or later or Sonnet 4.6). Auto mode runs everything without routine prompts, but a separate classifier model reviews each action first and blocks anything that escalates beyond your request — curl | bash, production deploys, force-push, mass deletion, pushing to main. Importantly, auto mode also nudges Claude to keep working without stopping for clarifying questions, so it helps with both kinds of asking at once.
Two caveats worth knowing:
- If the classifier blocks an action 3 times in a row or 20 times total, auto mode pauses and Claude Code resumes prompting. Approving the prompted action resumes it.
defaultMode: "auto"is honored only from~/.claude/settings.json(user settings). Claude Code v2.1.142+ ignoresautoin project.claude/settings.jsonso a repo can’t grant itself auto mode.
Auto mode is a research preview — it reduces prompts, it does not guarantee safety. Keep bypassPermissions for throwaway containers only.
Surgical: pre-approve specific tools
If you don’t want a blanket mode but a handful of commands prompt constantly, allow exactly those in settings.json. Rules evaluate deny → ask → allow (a matching deny always wins):
{
"permissions": {
"allow": ["Bash(npm test)", "Bash(npm run:*)", "Bash(git status)", "Bash(git diff:*)"],
"ask": ["Bash(git push:*)"],
"deny": ["Bash(rm -rf:*)"]
}
}Patterns: Bash(npm test) is an exact command, Bash(npm run:*) matches variants, Bash alone allows all Bash. This is the durable equivalent of clicking “Yes, and don’t ask again” — but checked into the repo so the whole team benefits.
Decision questions: make the answers explicit
These are the “TypeScript or JavaScript?” questions. Claude asks because your prompt is vague or your codebase is silent on conventions, so it answers safety with caution. The fix is never “tell it to stop asking” — that’s brittle. Make the defaults real.
Common causes (ordered by hit rate)
1. CLAUDE.md has no “Defaults” section. Without defaults written down, every implicit choice needs confirmation. Spot it: grep -i default CLAUDE.md returns nothing.
2. Prompt left obvious decisions implicit. “Add a new endpoint” doesn’t say which style, where, what framework. Spot it: your prompt is under 30 words and names no canonical example.
3. No autonomy authorization. Claude Code’s built-in policy leans toward asking on ambiguity. Correct for destructive ops, noise for reversible edits. Spot it: the questions are about reversible decisions (file location, naming), not destructive ones.
4. Pre-existing inconsistency in the codebase. Half your repo uses findUser, half getUser. Claude reads both, sees a real choice the code never made, and asks. Spot it: the question reflects an ambiguity you can actually find both sides of in src/.
5. The task is genuinely ambiguous. Some questions are fair: “where should this file live?” when five locations are plausible. Spot it: if you can’t answer instantly with the codebase open, it’s a valid question — answer it.
6. Plan mode is on. Plan mode is designed to ask before each step. If you didn’t mean to enter it, it feels like over-asking. Spot it: each “question” is a numbered step waiting for plan approval. Press Shift+Tab to leave plan mode.
Step 1: Add a “Defaults” section to CLAUDE.md
The single highest-leverage change. The classifier in auto mode and Claude itself both read CLAUDE.md, so this pays off everywhere:
## Defaults (do not ask, just use these)
- Language: TypeScript (strict mode)
- Test framework: vitest
- Test location: alongside source, named `*.test.ts`
- Package manager: pnpm
- API response shape: `{ data: T | null, error: string | null }`
- Error class: extend `AppError` from `src/lib/errors.ts`
- New components: arrow function, props destructured, exported as default
- Naming: `findX` for nullable lookups, `getX` for required (throws on missing)
## Always ask before:
- Deleting files outside the immediate task
- Running database migrations on prod
- Modifying `.env`, `package.json` engines, or CI config
- Changing public API contracts
- Force-pushing or `git reset --hard`The “Always ask before” block is what makes the “don’t ask otherwise” rule safe.
Step 2: Turn on the Proactive output style
This is the lever built for exactly this problem. The Proactive output style swaps Claude Code’s system prompt for one that makes it execute immediately, make reasonable assumptions instead of pausing for routine decisions, and prefer action over planning — while still showing permission prompts before tools run. The docs explicitly recommend it for stronger autonomous behavior when you want fewer clarifying questions but still want to approve the actual edits.
Set it via /config and pick the output style there, or set outputStyle directly in settings (the standalone /output-style command was removed in v2.1.91). Your selection is saved to .claude/settings.local.json.
Step 3: Point at a canonical example in the prompt
Instead of “add a new endpoint”:
Add `GET /api/orgs/:id` endpoint.
Follow `src/app/api/users/[id]/route.ts` exactly — same structure,
same error format, same test layout. Don't ask about location,
naming, or framework — match that file.A canonical pointer eliminates five questions in one sentence.
Step 4: Use an explicit “decisive mode” prompt prefix
For execution-mode work, save this as a slash command so you don’t retype it:
Mode: execute, not consult.
Read CLAUDE.md for defaults. Make reasonable decisions based on existing code.
Ask ONLY if:
1. The decision is destructive (deletes data, breaks API contracts)
2. The decision contradicts CLAUDE.md
3. Multiple existing patterns exist and you can't determine the canonicalStep 5: Pre-answer obvious questions in the prompt
For repeat workflows, front-load what the agent would ask:
Add tests: yes, vitest, alongside source.
File location: src/services/billing/.
Naming: camelCase, no `I` prefix on interfaces.
Documentation: JSDoc only on exports.Step 6: Resolve in-repo inconsistency
If Claude asks because your codebase doesn’t make a choice, fix the codebase:
# Count competing patterns
grep -rc "findUser" src/ | awk -F: '{s+=$2} END {print "find:", s}'
grep -rc "getUser" src/ | awk -F: '{s+=$2} END {print "get:", s}'Declare a winner in CLAUDE.md and migrate the minority pattern (can be a Claude task itself). Future tasks stop hitting the ambiguity.
Step 7: Treat every question as a doc gap
When Claude asks, judge: real gap, or a default it should already know? Either way, the answer goes into CLAUDE.md so it never asks twice.
Q: "Should the new endpoint require auth?"
→ Real question. Answer + add to CLAUDE.md: "All /api/* require auth except /api/public/*."
Q: "TypeScript or JavaScript?"
→ Default question. Answer + add: "Always TypeScript, strict mode."How to confirm it’s fixed
- Permission side: the status bar shows
⏵⏵ accept edits on(orauto), and a routine edit lands without a(y/n)prompt. Rungit diffto review what landed. - Decision side: re-run the same kind of task (
add a small endpoint following the canonical file). If Claude proceeds and only stops on something genuinely destructive or genuinely ambiguous, the defaults are working. If it still asks “TypeScript or JS?”, that exact answer isn’t in CLAUDE.md yet — add it.
FAQ
What’s the difference between accept-edits mode and auto mode?
acceptEdits auto-approves file edits and a short list of filesystem commands inside your working directory; everything else (other Bash commands, network calls, out-of-scope writes) still prompts. auto runs everything without routine prompts but routes each action through a background safety classifier, and it also pushes Claude to stop asking clarifying questions. Use accept-edits for normal coding you’ll review; use auto for longer hands-off runs you trust.
Is --dangerously-skip-permissions (YOLO mode) the way to stop the prompts?
It works (bypassPermissions mode skips all checks) but it offers no protection against prompt injection or model error, and Claude Code refuses to start in it as root. Use it only in throwaway containers or VMs. For everyday work, acceptEdits or auto give you most of the speed with the safety rails intact.
I set defaultMode: "auto" and the session still starts in default mode. Why?
auto is only honored from your user settings (~/.claude/settings.json). Since v2.1.142, Claude Code ignores defaultMode: "auto" in a project’s .claude/settings.json or settings.local.json so a repository can’t silently grant itself auto mode. Move the setting to your home settings file.
Claude stopped asking permission but still asks “which framework?” — did the mode not work?
Those are two different things. The permission mode silenced tool-approval prompts; it doesn’t teach Claude your conventions. Decision questions need CLAUDE.md defaults, a canonical example in the prompt, and ideally the Proactive output style. Fix that side separately.
Some questions are legitimately good. How do I keep those? Keep an “Always ask before” block in CLAUDE.md (destructive ops, prod migrations, public API changes), and state boundaries in chat — in auto mode, a line like “don’t push until I review” is treated as a hard block by the classifier until you lift it. You get silence on noise and a stop on anything that matters.
Will accept-edits delete files I didn’t mean to touch?
It auto-approves rm/rmdir/mv only inside your working directory or additionalDirectories, and never for protected paths like .git or .env. Writes outside scope still prompt. For a hard guarantee, add a deny rule such as Bash(rm -rf:*) in settings.json — deny rules win in every mode.
Related
- Claude Code does not understand the whole project
- Claude Code output does not match the prompt
- Claude Code misunderstands your project architecture
- Claude Code beginner guide
- Claude Code workflow
- Claude Code project setup
- Claude Code Creates a Pile of Unused Helpers
- Agent Rollback Was Incomplete
- Multi-Agent Conflict: Two Agents Edited the Same Files
- Claude Code Bash Sandbox Blocks an Expected Command
- Claude Code Session Resume Loses Memory of Prior Work
- Claude Code Statusline Custom Script Errors or Hangs