Stop Claude Code from editing your .env, force-pushing, and breaking the server/client split.

The failures it catches

Each row is a case the pack's own self-test runs (52 tests, all passing on Node 24 and 26).

What's in the zip

• CLAUDE.md template with a commands table, server/client rules, caching, NEXT_PUBLIC_ handling and git rules. Short enough to load every turn.
• 5 hooks: protect-files, guard-bash, check-client-boundary, typecheck-on-stop, format-changed (runs your own Prettier if installed), plus the .claude/settings.json that wires them up.
• 3 subagents: route-planner (server vs client, data, caching and auth decided before code), nextjs-reviewer (read-only diff review with file:line findings), test-writer (uses your existing runner and must run what it writes).
• /preflight: typecheck, lint, test and build, reported as one pass/fail table.
• Installer that never overwrites your files (your version stays; the pack's is saved as .pack-new).
• 52 self-tests, a setup guide, a troubleshooting guide, and a page listing exactly what each piece catches.

Free sample or the $15 pack?

Start free if you only want to protect files from accidental edits. Choose the pack if you want the additional Next.js checks and a ready-to-adapt workflow in one download.

Before you buy

Still checking the fit? Run the free sample's seven offline checks before deciding.

Start with your project instructions

New to project rules? Use our free CLAUDE.md template for Next.js, with a setup checklist and examples of server/client boundary mistakes.

Hook not firing? Follow the safe hook debugging checklist before changing your configuration.

Try the free hook before you buy

Download, inspect and run seven offline checks. No email, account or purchase. Nothing reads or edits your real secrets.

Download the free sample ZIP

Node 20+ · macOS/Linux · 6 small files, no dependencies. Includes the two hook files shown below, example settings, README, license and verifier.

1. Verify in a new empty folder

Unzip, inspect the source, and run this from the extracted folder:

node verify.mjs

Expected: seven PASS lines and 7 checks passed. Fictional paths sent on stdin prove that secret/generated-file edits are blocked while ordinary source edits are allowed. No real .env file is opened or changed.

2. Enable it without replacing your settings

Copy the two hook files into your project's .claude/hooks/ only after comparing any existing versions. Merge the entry from settings.example.json into .claude/settings.json; do not replace existing hooks or settings. Restart Claude Code and run /hooks to confirm it loaded.

The offline checks verify hook logic, not runtime wiring. If you test the live hook, use a throwaway project with dummy values, never real secrets. To uninstall, remove only this command's settings entry and restart Claude Code.

This sample guards edit-style tools only, not shell commands or reads. It is not a security boundary. Keep permission prompts, review and CI. The full pack adds the other checks listed above; no support or updates are included.

Prefer to inspect or copy the source?

Two pieces from the pack, unchanged. Use them even if you never buy the rest.

1. .claude/hooks/protect-files.mjs

Needs the small lib.mjs helper below next to it.

#!/usr/bin/env node
// PreToolUse (Edit|Write|MultiEdit|NotebookEdit)
// Blocks edits to secrets, lockfiles and generated output.
import path from "node:path";
import { readHookInput, block, allow, editedPaths, toPosix } from "./lib.mjs";

const ENV_OK = new Set([".env.example", ".env.sample", ".env.template"]);
const LOCKFILES = new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"]);
const GENERATED_DIRS = [".next", "node_modules", "out", ".vercel", ".turbo"];

function reasonToBlock(filePath) {
  const p = toPosix(filePath);
  const base = path.posix.basename(p);
  const segments = p.split("/");

  if (/^\.env(\..+)?$/.test(base) && !ENV_OK.has(base)) {
    return `${base} holds secrets. Do not edit it. If a new variable is needed, add it to .env.example with a placeholder value and tell the user which real value to set.`;
  }
  if (LOCKFILES.has(base)) {
    return `${base} is generated by the package manager. Change package.json and run the install command instead of editing the lockfile by hand.`;
  }
  const dir = GENERATED_DIRS.find((d) => segments.slice(0, -1).includes(d));
  if (dir) {
    return `${p} is inside ${dir}/, which is generated output. Edit the source file instead.`;
  }
  if (base === "next-env.d.ts") {
    return "next-env.d.ts is regenerated by Next.js. Put custom type declarations in a separate .d.ts file.";
  }
  return null;
}

const input = readHookInput();
for (const p of editedPaths(input)) {
  const reason = reasonToBlock(p);
  if (reason) block(`Blocked by protect-files hook: ${reason}`);
}
allow();

.claude/hooks/lib.mjs

// Shared helpers for the pack's hooks. Built-in Node modules only.
import { readFileSync } from "node:fs";

// Claude Code sends the hook payload as JSON on stdin.
export function readHookInput() {
  let raw = "";
  try {
    raw = readFileSync(0, "utf8");
  } catch {
    return {};
  }
  try {
    return JSON.parse(raw || "{}");
  } catch {
    return {};
  }
}

// Exit code 2 tells Claude Code to block the action (PreToolUse) or to show
// the message to Claude as feedback (PostToolUse / Stop). stderr is the message.
export function block(message) {
  process.stderr.write(message.trim() + "\n");
  process.exit(2);
}

export function allow() {
  process.exit(0);
}

// Every file path an edit-style tool is about to touch.
export function editedPaths(input) {
  const ti = input.tool_input || {};
  const paths = [];
  if (typeof ti.file_path === "string") paths.push(ti.file_path);
  if (typeof ti.notebook_path === "string") paths.push(ti.notebook_path);
  return paths;
}

export function toPosix(p) {
  return String(p).replace(/\\/g, "/");
}

Wire it up in .claude/settings.json

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write|MultiEdit|NotebookEdit",
        "hooks": [
          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/protect-files.mjs\"", "timeout": 10 }
        ]
      }
    ]
  }
}

Merge this entry with existing settings rather than replacing them. Use the offline verifier above before any live wiring check.

2. From the CLAUDE.md template

## Server and client components

- Files in `app/` are **Server Components** by default. Keep them that way.
- Add `"use client"` only to the smallest component that needs state, effects,
  event handlers or browser APIs. It must be the first line, above imports.
- Never import `server-only` modules, `next/headers`, database clients or
  secret-reading code into a client component. Fetch on the server and pass
  plain serializable props down.
- Client components cannot be `async` and cannot export `metadata`.

Requirements and limits

• Claude Code 2.1.x (tested on 2.1.283). Node 20 or newer (tested on 24 and 26). A Next.js App Router project.
• macOS and Linux. Windows is untested. The Pages Router is not covered.
• These are guardrails for common mistakes, not a security boundary. The Bash guard is pattern matching, and a command written to get around it can. Keep Claude Code's permission prompts, code review and CI.
• Sold as-is: one version, no updates or support included. The free sample above shows the style before you buy.