freeze

Restrict file edit and write operations to a user-configured directory.

11|2|Updated Mar 31, 2026
One-click install
npx skills add https://github.com/ajsai47/holyclaude --skill freeze-ajsai47
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/ajsai47/holyclaude/tree/main/skills/team/freeze
Command: npx skills add https://github.com/ajsai47/holyclaude --skill freeze-ajsai47

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When debugging or working on a single module, it is easy to accidentally edit files outside your intended scope, leading to unintended changes that break unrelated parts of your project.

Core Features & Use Cases

  • Edit Boundary Lock: Blocks all Edit and Write operations outside the user-specified allowed directory for the entire session.
  • Scoped Development: Ideal for debugging sessions, single-module feature work, or any scenario where you want to limit changes to a specific folder.
  • Use Case: If you are fixing a bug in the /src/utils directory, use freeze to ensure you do not accidentally modify files in /src/components or other unrelated folders while troubleshooting.

Quick Start

Use the freeze skill to restrict all file edits to your project's src directory for the rest of the session.

Frequently Asked Questions about freeze

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I restrict file edits to a specific directory during debugging?

Restricting file edits to a specific directory involves setting an edit boundary lock that blocks all write and edit operations outside your allowed folder for the entire session, preventing unintended modifications to unrelated code.

What is directory scoping for code protection?

Directory scoping for code protection is a change control mechanism that confines file write and edit operations to a user-configured folder, ensuring troubleshooting does not accidentally break unrelated project parts.

How do I prevent accidental file modifications in my project?

You can prevent accidental file modifications by applying an edit restriction that scopes all changes to a specific project folder, automatically blocking any write operations to files outside the configured directory boundary.

Does file lock scoping work for single-module development tasks?

Yes, file lock scoping works effectively for single-module development tasks by validating file paths against the allowed directory and blocking edit operations outside that boundary for the entire duration of your work session.

What are the limitations of edit restriction boundaries?

The main limitation of edit restriction boundaries is that the lock applies to a single user-configured directory for the entire session, meaning you cannot dynamically change the allowed scope without reconfiguring the freeze boundary.