Claude Code's --dangerously-skip-permissions: What It Actually Risks
Claude Code's --dangerously-skip-permissions flag is the same as --permission-mode bypassPermissions: the agent stops asking before it acts. Here is what that turns off, what still applies, where Anthropic says it belongs, and how to see what the agent did when nobody was asked.
What it turns off, and what still applies
In the words of Claude Code's permission modes documentation, the mode "disables permission prompts and safety checks so tool calls execute immediately, including writes to protected paths." In practice:
- Off: every permission prompt, and the checks behind them. Allow rules have no effect, because nothing needs allowing.
- Still on: deny rules ("deny rules block in every mode"), explicit ask rules, and the prompt for removing critical paths.
- Refused as root: on Linux and macOS, Claude Code will not start in this mode with root or sudo privileges.
Anthropic is direct about where it belongs:
"Only use this mode in isolated environments like containers, VMs, or dev containers without internet access, where Claude Code cannot damage your host system."
And: it "offers no protection against prompt injection or unintended actions."
What it actually puts at risk
- Everything your user account can reach. Not just the project: your home folder,
~/.ssh, cloud credentials, other repositories, your shell's startup files. The agent runs as you. - Instructions you did not write. An agent reads files, issues and web pages. If one of them steers it, there is no prompt left to catch the result.
- The gap between commands and effects. Deny rules still apply, but they match command text. One user tried seven ways to delete a folder against a deny rule for
rm: plainrmwas blocked, python and a script file deleted it anyway. Another, running in a container, watched an agent runrm -rf $D/with$Dempty, though they "even have a rule in place to prevent" it.
And sometimes nothing in between catches anything at all. From one developer who runs it constantly:
"I run claude code --dangerously-skip-permissions all the time … Well, the worst finally happend claude issued a command to delete all files on my C: directory."
Nothing of value was lost in that case, because it was a gaming and build machine. That is the point: the mode is only as safe as the machine it runs on.
Why people run it anyway
Because the prompts interrupt real work. An agent that stops every few minutes to ask about npm test is hard to use for anything long. That is a real cost, and the answer is not to tell people to stop; it is to give the agent a machine where saying yes to everything is acceptable, and a record of what it did.
Getting the speed more safely
- Auto mode. A separate classifier reviews actions before they run and blocks the risky ones, with far fewer prompts. Its own documentation adds that it "reduces permission prompts but does not guarantee safety."
- A container, VM or dev container, as a non-root user and without internet access, as Anthropic recommends. A dedicated dev box works the same way.
- Deny rules for what must never happen, knowing they block a command, not every way to its effect.
- Nothing in reach that you cannot lose: no production credentials in that account, and backups of anything that matters.
Seeing what it did
In this mode nobody reviews the actions as they happen, so the record afterward is the only review there is. kaimon gives you that record for AI coding agents on Linux:
- Every file the agent changes or deletes, recorded in the Linux kernel with no hooks and no agent plugins, so a command that slipped past a rule is recorded like any other.
- Attributed and risk-rated. The categories that matter most here: CRED WRITE for SSH keys and credentials, PERSISTENCE and SHELL MOD for startup hooks and shell profiles, MASS DELETE for recursive deletes, GIT REWRITE for rewritten history, and AGENT MUTATE for an agent changing its own instructions, settings or MCP servers.
- Where you work: severity in the VS Code status bar, the top findings on hover, the details in the panel, and a report in HTML and JSON.
- Tamper-resistant: kaimon runs as a root daemon, so an agent working as your user can read the record but not change or delete it.
Stated plainly: kaimon does not tell you that the mode was on. It shows what happened while it was. It observes and never blocks, records from the moment it is installed, and runs on Linux, including a Linux dev box or VM you work on from macOS or Windows over VS Code Remote-SSH.
Always free and 100% local: nothing leaves your machine. See how it works, or read what to check when an agent deleted your files.
FAQ
Does --dangerously-skip-permissions disable deny rules?
No. Deny rules block in every mode, including this one. Allow rules have no effect, and explicit ask rules still prompt. Deny rules match commands, though, so the same effect reached another way is not blocked.
Is auto mode a safe replacement?
It blocks far more than skip-permissions, because a classifier reviews actions before they run. Its documentation says it reduces prompts but does not guarantee safety.
Can kaimon tell whether an agent ran with --dangerously-skip-permissions?
Not today. It records what the agent did to files, attributed and risk-rated, which is what matters most in a mode where nobody reviewed the actions.
Is it safe to use in a container?
That is what Claude Code's documentation recommends: a container, VM or dev container without internet access, run as a non-root user, where the agent cannot damage the host.