Permission Modes Explained: Auto-Accept vs Ask-Every-Time
Claude Code can act on your project autonomously, editing files and running shell commands as part of its agent loop.
How much it does before checking with you is governed by permission mode.
There are two: auto-accept, where it proceeds without asking each time, and ask-every-time, where it pauses for your approval before each action.
Choosing between them is one of the first real decisions you make once you understand the basic agent mental model.
Summary
- Core Idea: Permission mode controls whether Claude Code asks for approval before each individual action, or proceeds through its plan without interruption.
- Why It Matters: The same underlying agent loop can feel either fast and hands-off or careful and supervised, purely based on this one setting.
- Key Concepts: auto-accept, ask-every-time, the approval checkpoint, and how permission mode differs from Plan Mode.
- When to Use: ask-every-time for unfamiliar codebases or high-stakes changes; auto-accept for well-scoped, low-risk, or already-reviewed tasks.
- Limitations / Trade-offs: ask-every-time slows you down with frequent prompts; auto-accept requires trust in the plan and good version control as a safety net.
- Related Topics: the agent mental model, Plan Mode versus execution mode, terminal setup for fast approvals.
Foundations
Every action Claude Code takes as part of a task, editing a file, creating a new one, running a shell command, is a discrete step it could either perform immediately or pause on for your approval.
Ask-every-time mode pauses on each of these steps.
You see what it wants to do, and you approve, adjust, or reject it before it happens.
Auto-accept mode skips that pause.
Claude Code proceeds through its entire plan, and you review the outcome afterward, typically as a diff or a summary of what changed.
A simple way to think about it: ask-every-time is supervising someone step by step, while auto-accept is handing off a task and checking the finished result.
Neither mode changes how well Claude Code plans; it only changes when you get to intervene.
Mechanics & Interactions
The choice between modes interacts directly with how much you already trust the agent's plan for a given task.
A multi-file refactor in a codebase you know well, where you have already reviewed similar changes before, is a reasonable candidate for auto-accept.
The same kind of change in a codebase you inherited yesterday is a much better candidate for ask-every-time, purely because you have less basis to predict whether the plan matches your intent.
Permission mode is also independent of Plan Mode, and conflating the two is one of the most common points of confusion for new users.
Plan Mode controls whether real edits are allowed to happen at all: in Plan Mode, Claude Code can read and reason, but not write.
Permission mode only matters once execution is allowed, controlling how much approval each individual write requires.
# ask-every-time: a checkpoint before each action
claude --permission-mode ask-every-time
# auto-accept: the plan runs through without per-step interruption
claude --permission-mode auto-acceptYou can combine these two independent settings freely.
Reviewing a plan in Plan Mode and then switching to execution with auto-accept is a common pattern: you already vetted the plan, so per-step prompts during execution add friction without adding safety.
Reviewing a plan in Plan Mode and then switching to execution with ask-every-time adds a second layer of caution, useful for changes with real consequences if something goes wrong.
Advanced Considerations & Applications
As you get more comfortable with Claude Code, the natural trend is toward using auto-accept more often, because well-scoped requests in familiar codebases tend to produce plans that match your intent.
That said, ask-every-time remains the right default in a few recurring situations: destructive operations like deleting files or database migrations, changes to authentication or payment code, and any session in a codebase you did not write yourself.
Version control is the practical safety net underneath both modes.
Auto-accept in particular depends on you being able to review a diff and revert cleanly if the outcome is wrong, so committing your work before a big auto-accept session is a reasonable habit.
| Approach | Strength | Weakness | Best Fit |
|---|---|---|---|
| Ask-every-time | Maximum oversight, catches bad plans before they execute | Slower, requires attention at every step | Unfamiliar codebases, destructive or high-stakes changes |
| Auto-accept | Fast, minimal interruption, good flow for repetitive work | Requires trust in the plan and a safety net like version control | Well-scoped, low-risk, or already-reviewed tasks |
| Plan Mode first, then either permission mode | Adds a review checkpoint before any real edits happen | Adds an extra step for simple, obviously safe tasks | Risky or unfamiliar changes where you want to vet the plan itself |
Teams onboarding new developers onto Claude Code generally start everyone on ask-every-time, then let individual developers move to auto-accept as they build a track record with the tool in that specific codebase.
Common Misconceptions
- "Auto-accept means it can do anything without limits." - Auto-accept removes the per-step approval prompt, but the agent is still working from your instruction; it is not granted unrelated permissions beyond the task you gave it.
- "Ask-every-time makes Claude Code safer overall." - It makes individual actions more supervised, but a vague instruction can still lead to a bad plan; the mode changes when you catch a mistake, not whether one can happen.
- "Permission mode and Plan Mode are the same setting." - They are not. Plan Mode governs whether edits happen at all; permission mode governs approval once edits are allowed.
- "I should pick one mode and use it for everything." - Most experienced users switch modes based on the task and codebase, rather than fixing on one mode permanently.
- "Auto-accept is only for advanced users." - It's more accurate to say auto-accept is for well-scoped, low-risk tasks regardless of the user's experience level; a beginner doing a small, safe change can reasonably use it too.
FAQs
What's the actual difference between auto-accept and ask-every-time?
- Ask-every-time pauses for your approval before each individual file edit or shell command.
- Auto-accept proceeds through the full plan without pausing, and you review the result afterward.
- Both modes use the same underlying agent loop; only the approval checkpoint differs.
Which mode should I use as a beginner?
Ask-every-time is a reasonable default while you're still building trust in how Claude Code plans tasks in your codebase. You can move to auto-accept for specific well-scoped tasks once you're comfortable.
Does permission mode affect how well Claude Code plans a task?
No. Permission mode only affects when you get to intervene, not the quality of the underlying plan. A vague instruction can still produce a weak plan in either mode.
Is permission mode the same thing as Plan Mode?
No, they're independent. Plan Mode controls whether real edits happen at all. Permission mode controls how much approval each edit requires once execution is allowed.
Can I switch permission mode mid-session?
Yes, in most setups you can change your permission mode without ending the session, letting you tighten or loosen oversight as the task's risk level changes.
What should I never run in auto-accept mode?
- Destructive operations like deleting files or dropping database tables.
- Changes to authentication, payments, or other high-stakes code paths.
- Any session in a codebase you don't know well yet.
Does auto-accept skip version control safety too?
No, version control is unaffected by permission mode. In fact, committing your work before an auto-accept session is a good habit, since it gives you a clean point to revert to if the outcome is wrong.
Why would I combine Plan Mode with auto-accept instead of ask-every-time?
If you already reviewed and approved the plan in Plan Mode, per-step prompts during execution add friction without adding much additional safety, since you already vetted the intent.
Do teams usually standardize on one permission mode?
Many teams start new developers on ask-every-time as a shared default, then let individuals move to auto-accept as they build confidence with the tool in that specific codebase.
Is there a middle ground between the two modes?
The two named modes are the core options, but combining permission mode with Plan Mode (reviewing the plan first, then choosing how to execute) effectively gives you a middle ground for cautious-but-efficient workflows.
Related
- The Claude Code Mental Model: Agent, Not Autocomplete - the underlying agent loop that permission mode governs.
- Switching Between Plan Mode and Execution Mode - the independent safety mechanism that pairs with permission mode.
- Claude Code 101 Basics - see permission mode chosen as part of a first session.
- Claude Code 101 Best Practices - onboarding guidance that includes choosing a starting permission mode.
Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5. Model names, pricing, and product features move quickly - verify current specifics at platform.claude.com/docs before relying on them.