The Scope Lock Prompt: Stop AI From Refactoring Code You Didn't Ask It to Touch

Here's a frustrating pattern: you ask an AI assistant to fix a bug in one function, and it comes back with changes to three files, a renamed variable, and a "small improvement" to your error handling.

The fix is embarrassingly simple. I call it the scope lock.

The Problem

AI coding assistants optimize for "helpfulness." When they see adjacent code that could be "improved," they improve it — even when you didn't ask. This creates three problems:

1. Harder code review — you're reviewing changes you didn't request
2. Hidden regressions — the "improvements" might break something
3. Noisy diffs — your PR becomes a mix of the fix and unrelated cleanup

The Scope Lock Template

Add this block to any prompt where you want precise changes:

SCOPE LOCK:
- Only modify: [list specific files or functions]
- Do not rename, reformat, or refactor anything outside the scope
- If you see something outside scope that needs fixing, mention it
  in a comment at the end — do not change it
- Show me the exact diff of what you changed

Example in Practice

Without scope lock:

The `processOrder` function in orders.ts throws when quantity is 0.
Fix it.

Result: AI fixes the bug, renames qty to quantity everywhere, adds JSDoc comments, and extracts a helper function.

With scope lock:

The `processOrder` function in orders.ts throws when quantity is 0.
Fix only this function. Do not rename variables, add comments, or
extract helpers. If you notice other issues, list them at the end.

SCOPE: orders.ts → processOrder() only

Result: A 3-line fix. Plus a note at the bottom saying "I noticed validateOrder has a similar issue — want me to look at it?"

Why "Mention It, Don't Fix It" Works

The "mention but don't change" instruction is the key insight. It gives the model an outlet for its helpfulness without polluting your diff. You get the benefit of the AI's code review eye without the cost of unwanted changes.

I keep a running list of these suggestions and batch them into a separate cleanup PR when I have time.

Combining With Git Workflow

This pairs well with canary branches:

1. Scope lock the prompt
2. Apply changes to a canary branch
3. Run git diff --stat — if it shows files outside your scope, the lock failed
4. If clean, squash-merge

The scope lock catches ~90% of drift. The canary branch catches the rest.

When to Skip It

For greenfield code (new files, new features), scope locks are unnecessary overhead. The AI can't drift if there's nothing adjacent to drift into.

Use scope locks when:

• Fixing bugs in existing code
• Adding features to existing files
• Any prompt that says "modify" or "update"

Have you tried something similar? I've been experimenting with different constraint formats — curious what works for others.