What is --dangerously-skip-permissions in Claude Code?

Feb 22, 2026

Purpose

This post explains what the --dangerously-skip-permissions flag does in Claude Code and when you should (and shouldn’t) use it.

What is —dangerously-skip-permissions?

When you run Claude Code normally, it asks for permission before executing commands or making changes. The --dangerously-skip-permissions flag disables these safety checks.

I can explain what this means in practice. By default, Claude Code requires confirmation for:

Bash commands: Every shell execution needs approval
File operations: Writing, editing, or deleting files prompts for permission
Destructive tools: Commands that modify system state require explicit consent

When you use the flag:

claude --dangerously-skip-permissions

Claude can execute tools and commands without asking for approval. This enables fully autonomous “agentic” behavior where Claude can complete complex multi-step workflows without interruption.

Why would you use this?

I think there are good reasons to use this flag in specific situations. Let me explain the benefits:

True agentic workflows: Claude can complete complex multi-step tasks without stopping to ask for permission at each step. This is useful for long-running workflows that would otherwise require constant babysitting.

Faster iteration: No waiting for approval on every command. For automation scripts or trusted development environments, this removes friction from the workflow.

Better automation: Scripts and workflows run end-to-end. Claude can chain together multiple operations like installing dependencies, creating configuration files, and running builds without interruption.

But I need to be clear about the risks. The flag includes “dangerously” in the name for a reason:

Unintended file operations: Claude could delete or modify files you didn’t want changed Harmful commands: Without confirmation, mistakes execute immediately Cascading errors: One bad command could trigger more bad commands No safety net: You lose the chance to catch mistakes before they happen

When is it safe to use this flag?

I would only use --dangerously-skip-permissions in controlled environments:

Isolated environments: Docker containers, VMs, WSL instances where damage is contained Throwaway systems: Temporary development boxes you can recreate easily Version-controlled projects: Git can revert changes if something goes wrong Trusted workflows: Well-tested scripts and automation you’ve validated Hobby/experimental projects: Low-risk personal work where mistakes are acceptable

I would avoid using it for:

Production systems with real users or data
Critical infrastructure that can’t go down
Irreplaceable data without backups
Shared environments where others might be affected
Untrusted AI outputs from prompts you haven’t tested

How the permission system works

I can show you what happens with and without the flag.

Default behavior (with permissions):

$ claude

Claude: I'll install the dependencies.
[Bash] npm install
Allow this command? [Y/n] Y

Claude: Now I'll create the config file.
[Write] /app/config.json
Allow writing to this file? [Y/n] Y

Claude: Finally, I'll run the build script.
[Bash] npm run build
Allow this command? [Y/n] Y

With —dangerously-skip-permissions:

$ claude --dangerously-skip-permissions

Claude: I'll install dependencies, create the config, and run the build.
[Bash] npm install
<runs immediately without asking>

[Write] /app/config.json
<writes immediately without asking>

[Bash] npm run build
<runs immediately without asking>

Done! The project is set up and built.

The difference is clear. With the flag, Claude works autonomously. Without it, you maintain control through approval prompts.

Safe setup pattern

I recommend setting up an isolated environment if you want to use autonomous workflows. Here’s a pattern I use:

# Create isolated environment for autonomous workflows
docker run -it --rm \
  -v $(pwd):/workspace \
  -w /workspace \
  node:20 \
  bash

# Inside container - safe to use the flag
npx -y @anthropic-ai/claude-code --dangerously-skip-permissions

This approach gives you the benefits of autonomous operation while containing potential damage to a disposable container.

Alternative: Selective permission bypass

I’ve found that you don’t always need the nuclear option. Claude Code’s settings file (~/.claude/settings.json) lets you configure more granular control:

{
  "autoAcceptPermissions": {
    "read": true,
    "grep": true,
    "glob": true
  },
  "allowedTools": ["read", "write", "bash"],
  "dangerouslyAllowedPatterns": [
    "npm install",
    "npm run build",
    "git status"
  ]
}

This configuration allows specific safe operations without fully bypassing the permission system. Read-only operations like grep and glob run automatically, while riskier operations still require approval unless they match trusted patterns.

Common mistakes

I’ve seen these mistakes in community discussions:

Using the flag on production systems: This is high-risk and unnecessary. Production environments should always have safeguards.

Forgetting which mode you’re in: It’s easy to forget you enabled the flag, leading to accidental deletions or modifications.

Assuming Claude won’t make mistakes: Claude can misinterpret prompts, make typos in commands, or execute operations you didn’t intend.

Not having backups: Even in development, you should have backups when using autonomous mode.

Leaving it enabled for normal sessions: The flag is meant for specific automation tasks, not everyday interactive use.

Summary

In this post, I explained what the --dangerously-skip-permissions flag does in Claude Code. The key point is that this flag transforms Claude from an “ask-first” assistant into a “just-do-it” agent. It’s powerful, but requires careful environment setup to use safely.

I think the permission system exists for good reason: it prevents accidents and gives you control. But for isolated, version-controlled environments with trusted workflows, skipping permissions enables the kind of autonomous agentic behavior that makes AI coding assistants truly powerful.

The best approach depends on your use case. For quick tasks or production work, keep the permissions enabled. For automation in disposable containers on version-controlled projects, the flag unlocks Claude’s full potential as an autonomous agent.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Claude Code Documentation
👨‍💻 Reddit discussion about --dangerously-skip-permissions
👨‍💻 Understanding AI Agent Safety

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!