safe-mode — Claude Code skill: what it does, how to install
safe-mode intercepts destructive terminal commands and confines agent edits to a specific directory using Claude Code hooks.
MIT ★ 2,966 updated 2026-09-29
/plugin marketplace add rohitg00/pro-workflow
/plugin install pro-workflow@pro-workflowWhat safe-mode does
The skill binds a PreToolUse handler to Bash, Edit, and Write actions via scripts/safe-mode-guard.js. It activates only upon calling /safe-mode and remains inert until you explicitly select an enforcement level.
Under cautious, the guard inspects shell commands against a predefined blocklist. Patterns like recursive deletions, DROP TABLE, git push --force, or remote script execution piped into shells trigger an explicit permission prompt. Under lockdown <path>, the script inspects relative paths, traverses symlinks, and halts any modifications outside the chosen directory with exit code 2. Both levels can run together, while clear resets everything.
Node.js is mandatory on your machine to execute the guard script. Settings persist inside $TMPDIR scoped by project root hashes, preventing settings from leaking across workspaces.
What it helps with
- block destructive commands like
rm -rfandsudo rm - prevent database data loss from
DROPorTRUNCATE - restrict agent code edits to a single target directory
- stop forced git pushes and destructive tree resets
Example prompts for the agent
- /safe-mode cautious
- /safe-mode lockdown src/api/
- /safe-mode clear
How to install safe-mode
1Plugin marketplace
/plugin marketplace add rohitg00/pro-workflow/plugin install pro-workflow@pro-workflowThis installs the whole pro-workflow plugin with all its skills
2Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill safe-mode -a claude-code3Manually: put the files in place
~/.claude/skills/safe-mode/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/safe-mode/
1Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill safe-mode -a codex2Manually: put the files in place
.agents/skills/safe-mode/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill safe-mode -a cursor2Manually: put the files in place
.cursor/skills/safe-mode/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rohitg00/pro-workflow skills/safe-mode2Manually: put the files in place
.github/skills/safe-mode/SKILL.md1Skills CLI (Vercel)
npx skills add rohitg00/pro-workflow --skill safe-mode -a gemini-cli2Platform CLI
gemini skills install https://github.com/rohitg00/pro-workflow --path skills/safe-modeManually: put the files in place
.devin/skills/safe-mode/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about safe-mode
How to install safe-mode in Claude Code?
Run /plugin marketplace add rohitg00/pro-workflow first, then run /plugin install pro-workflow@pro-workflow.
What is safe-mode?
It is an operational safeguard for Claude Code that prompts for confirmation before dangerous shell commands and locks edits inside an allowed path.
Does cautious mode abort commands outright?
It does not stop execution immediately; it raises a permission prompt so you can approve or reject the action manually.
Source text
SKILL.md · MIT
---
name: safe-mode
description: Prevent destructive operations using Claude Code hooks. Three modes — cautious (warn on dangerous commands), lockdown (restrict edits to one directory), and clear (remove restrictions). Uses PreToolUse matchers for Bash, Edit, and Write.
user-invocable: true
hooks:
PreToolUse:
- matcher: "Bash|Edit|Write"
hooks:
- type: command
command: "node \"${CLAUDE_PLUGIN_ROOT}/scripts/safe-mode-guard.js\""
---
# Safe Mode
Three levels of protection against destructive operations during AI coding sessions.
> **Note:** These hooks are skill-scoped — they only activate when you invoke `/safe-mode`. The global `permission-request.js` hook in hooks.json provides always-on alerting for dangerous commands. Safe-mode adds opt-in blocking and directory restrictions on top of that.
## Modes
### Cautious Mode
```text
/safe-mode cautious
```
Intercepts Bash commands before execution. Warns on dangerous patterns but does not block — the user decides.
**Flagged patterns:**
| Pattern | Risk |
|---------|------|
| `rm -rf` / `rm -r` | Recursive deletion |
| `DROP TABLE` / `DROP DATABASE` | SQL data loss |
| `TRUNCATE` | SQL data destruction |
| `git push --force` / `git push -f` | Remote history rewrite |
| `git reset --hard` | Local history loss |
| `git clean -f` | Untracked file deletion |
| `git checkout .` / `git restore .` | Discard all changes |
| `chmod 777` | World-writable permissions |
| `curl` or `wget` piped to a shell | Piped remote execution |
| `> /dev/sda` / `dd if=` | Disk-level operations |
| `:(){ :\|:& };:` | Fork bombs |
| `sudo rm` | Elevated deletion |
**What happens:** the hook returns a permission `ask`, so Claude Code shows you a prompt that names the pattern, for example `Safe mode: rm with -r or -f`. You approve or reject the command. This prompt appears even in auto mode.
### Lockdown Mode
```text
/safe-mode lockdown <path>
```
Restricts Edit and Write operations to a single directory tree. Prevents accidental changes to unrelated code.
**How it works:**
1. Set the allowed path (absolute or relative to repo root)
2. Every Edit/Write call checks if the target file is inside the allowed path
3. Operations outside the path are blocked with an explanation
```text
LOCKDOWN ACTIVE: Edits restricted to src/api/
Blocked: Edit to src/utils/helpers.ts
Reason: File is outside the lockdown path (src/api/)
To edit files outside the lockdown, run: /safe-mode clear
```
**Use cases:**
- Focused refactoring of one module without touching others
- Bug fix in a specific directory while tests run elsewhere
- Junior developer guardrail — scope the blast radius
- Code review session — only edit the files under review
**Scope:** Keyed to the project root. It stays set until `/safe-mode clear`, and only enforces in sessions where `/safe-mode` was invoked.
### Clear
```text
/safe-mode clear
```
Removes all restrictions for the current session. Both cautious warnings and lockdown restrictions are disabled.
```text
SAFE MODE: All restrictions cleared for this session.
```
## Implementation
Invoking this skill registers one `PreToolUse` hook for `Bash|Edit|Write` that runs `scripts/safe-mode-guard.js`. Skill hooks stay registered for the rest of the session. The guard does nothing until a mode is set.
### Set the mode
When the user runs `/safe-mode <mode>`, run the guard's setter from the project root:
```bash
node "${CLAUDE_PLUGIN_ROOT}/scripts/safe-mode-guard.js" set cautious
node "${CLAUDE_PLUGIN_ROOT}/scripts/safe-mode-guard.js" set lockdown src/api/
node "${CLAUDE_PLUGIN_ROOT}/scripts/safe-mode-guard.js" set clear
```
Then report the line the setter prints.
### Cautious (Bash)
The guard checks `tool_input.command` against a fixed list of destructive patterns: recursive or forced `rm`, `DROP` and `TRUNCATE`, force-push, hard reset, `git clean -f`, discarding all changes, `chmod 777`, piping `curl` or `wget` to a shell, disk-level writes, fork bombs, and `sudo rm`. A match returns `permissionDecision: "ask"` with the pattern as the reason. No match passes through.
### Lockdown (Edit and Write)
The guard resolves `tool_input.file_path` against the project root, follows symlinks, and checks that it sits inside the lockdown path. Inside passes through. Outside exits 2, which blocks the edit and tells Claude why.
### State
The mode lives in `$TMPDIR/pro-workflow/safe-mode-<hash>.json`, keyed by the project root, so two projects never share it:
```json
{ "cautious": true, "lockdownPath": "/Users/dev/project/src/api", "root": "/Users/dev/project" }
```
`set clear` deletes the file. The file outlives the session, so clear it when you are done; a new session only enforces it again after `/safe-mode` is invoked, because the hook is skill-scoped.
## Combining Modes
Cautious and lockdown can run simultaneously:
```text
/safe-mode cautious
/safe-mode lockdown src/api/
```
Now you get:
- Bash command warnings for destructive operations
- Edit/Write restrictions to `src/api/` only
Clear removes both.
## When to Use
| Situation | Mode |
|-----------|------|
| Working on production-adjacent code | Cautious |
| Focused refactoring of one module | Lockdown |
| Unfamiliar codebase, feeling cautious | Cautious |
| Pair programming, limiting AI scope | Lockdown |
| Done with restrictions | Clear |
## Anti-Patterns
- Leaving lockdown on when you need to edit tests (update the path or clear it)
- Using safe-mode as a substitute for git branches (branches protect history, safe-mode protects the session)
- Ignoring cautious warnings repeatedly (if you always proceed, turn it off — false confidence is worse)
© Rohit Ghumare · MIT · rohitg00/pro-workflow