freeze

Block Edit and Write operations outside a specified directory boundary.

Updated Mar 30, 2026
One-click install
npx skills add https://github.com/GenEducation/GenedUIProject --skill freeze-geneducation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/GenEducation/GenedUIProject/tree/main/.gemini/skills/freeze
Command: npx skills add https://github.com/GenEducation/GenedUIProject --skill freeze-geneducation

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents accidental or unwanted edits outside a chosen folder, making it easier to debug, refactor, or experiment without touching unrelated parts of a codebase.

Core Features & Use Cases

  • Scoped edit enforcement: Blocks Edit and Write operations that target files outside the selected directory.
  • Session persistence: Stores the freeze boundary so the restriction continues throughout the conversation.
  • Safety-oriented workflow: Useful when you want to focus changes on one module, protect a production area, or avoid collateral edits during troubleshooting.

Quick Start

Ask the skill to freeze edits to the directory you want to protect, such as a single feature folder or module path.

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?

Directory boundary enforcement blocks Edit and Write operations outside a selected folder using pre-tool validation hooks. It prevents accidental or unwanted edits to unrelated parts of a codebase during debugging, refactoring, or experimentation.

Can I lock file changes to one folder without affecting the rest of the codebase?

Yes, locking file changes to one folder is achieved by normalizing paths and persisting a freeze state. This ensures only files within the chosen module path are writable, while all other directories remain protected from modifications.

How do I prevent accidental edits outside a module when refactoring?

Preventing accidental edits outside a module requires scoped edit enforcement. By setting a freeze boundary on your target folder, any Edit or Write operations targeting files outside that directory are automatically blocked before execution.

Does edit restriction work across an entire debugging session or just one command?

Edit restriction works across an entire debugging session through session persistence. The freeze boundary is stored and maintained, so the directory restriction continues throughout the conversation rather than applying to a single command.

What's the best way to protect a production folder from stray edits during troubleshooting?

The best way to protect a production folder is to set a freeze boundary that blocks Edit and Write operations outside that directory. This safety-oriented workflow lets you troubleshoot and experiment while preventing collateral edits to critical areas.

When should I not use directory-scoped edit restrictions?

Directory-scoped edit restrictions should not be used when your workflow requires modifying files across multiple folders or modules simultaneously. The freeze boundary blocks all Edit and Write operations outside the allowed path, which limits cross-directory refactoring.