Skip to main content
skill CX Codex

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

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rohitg00/pro-workflow
/plugin install pro-workflow@pro-workflow
Open on GitHub

What 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 -rf and sudo rm
  • prevent database data loss from DROP or TRUNCATE
  • 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-workflow

This installs the whole pro-workflow plugin with all its skills

2Skills CLI (Vercel)

npx skills add rohitg00/pro-workflow --skill safe-mode -a claude-code

3Manually: put the files in place

~/.claude/skills/safe-mode/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/safe-mode/

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

Similar skills

All skills for Security →

From the same set83

The whole set →
agent-teams agent-teams is a Claude Code skill that coordinates multiple sessions through shared tasks, messaging, and file locks. Teammates work in parallel on separate parts of the codebase. CX Codex +1 ★ 2,966repo stars sprint-status sprint-status tracks parallel Claude Code sessions and prevents confusion by enforcing session headers and standardized status lines. CX Codex +1 ★ 2,966repo stars skill-router The skill-router skill maps pro-workflow skills and commands to jobs, with guidance on when to use each and whether a person or the agent starts it. Use it when you’re unsure what fits. CX Codex +1 ★ 2,966repo stars permission-analyst permission-analyst analyzes permission prompts and auto mode denials, recommends permissions rules and autoMode entries. Use it when prompts slow you down or auto mode keeps falling back to confirmations. CX Codex ★ 2,966repo stars wiki-research-loop wiki-research-loop is a Claude Code skill that researches a topic and adds pages to a wiki. It runs on requests such as research <topic> or instructions to grow a wiki automatically. CX Codex +1 ★ 2,966repo stars survey-generator survey-generator generates structured literature surveys on AI/ML topics. Output is a wiki page in markdown with bibliography, not a one-off HTML file. CX Codex +1 ★ 2,966repo stars context-engineering context-engineering guides Claude Code through the four context operations — Write, Select, Compress, and Isolate — to prevent context degradation. CX Codex +1 ★ 2,966repo stars learn learn is a Claude Code command that shows topic-based guidance and saves confirmed takeaways from a session. CX Codex +1 ★ 2,966repo stars

Project sponsors

Companies that keep this analytics open