
Scope creep prevention
The amendment protocol at scale. Refusing “while we’re in there” without becoming an obstacle.
Why scope creep is harder with agents
Agents are helpful by default. Helpful is normally a feature. With scope, helpful is a bug. The agent reads the surrounding code, notices three nearby issues, and fixes them because they were right there. Each individual fix is reasonable. The cumulative effect: contracts that triple in size, PRs that take 5x to review, reverts that touch ten files instead of one.
Discipline alone won’t prevent this.The agent will helpfully expand scope every time unless there’s an explicit standing rule that overrides the helpful default. The rule has to live in the CLAUDE.md, fire at every contract, and be reinforced when it slips.
The good news: one short standing rule covers ~80% of the cases. The remaining 20% are amendments — a slightly more involved protocol when the operator (or the agent) genuinely needs to expand mid-contract.
The three moves
The cumulative discipline. Together these three moves cover most of the scope-creep surface area.
| Move | When it fires | What it does |
|---|---|---|
| 1. Flag, don’t fix | Agent notices nearby issues during in-scope work | Agent surfaces side-quests as proposals; doesn’t act inline |
| 2. Amend, don’t expand | Operator asks for additions mid-contract | Small additions amended in place; large ones re-sign the contract |
| 3. Done means done | After hitting the definition of done | Improvements become a new contract; no infinite-revise loop |
The first move is the cheapest and pays back the most. Add the standing rule to your CLAUDE.md and ~80% of side-quest creep stops. The other two moves cover the cases where you, the operator, are the source of the creep, and those need a different discipline.
Three creep patterns
Where scope expands without anyone noticing it’s happening. Hover any card to see the diagnosis.
The helpful side-quest
The infinite improvement loop
The expanding context
The fix in all three: preempt with rules; amend instead of silently expand; treat done as a hard gate.The discipline is structural, not motivational — it’s easier than it sounds because the rules do the work.
The drift check
The diagnostic. Run mid-contract or at contract close. Surfaces work that happened outside the contract’s stated scope without amendment.
Check the current sprint contract for drift.
Compare:
1. The contract's stated scope (definition of done,
acceptance criteria)
2. The work actually done in the last 5 sessions
(commits, edits, conversations)
Flag drift in three categories:
- IN-SCOPE: work that matches the contract — no action
- AMENDED: work that was added with explicit amendment
to the contract — no action
- UNTRACKED-DRIFT: work outside the contract that
wasn't amended — this is the problem
For each untracked-drift item, recommend:
- Was this a justified expansion? (Then: amend the
contract retroactively, document why.)
- Was this side-quest creep? (Then: revert if reversible,
note in the contract for future cleanup if not.)
- Was the original contract too narrow? (Then:
re-sign with broader scope before continuing.)Compares contract scope to actual work. Untracked drift is the canary.
Healthy contracts have ~0 untracked drift. 1-2 small items per contract is acceptable (the “typo and one-line bug” exception). 3+ untracked drift items in a single contract means the standing rule isn’t firing — likely needs reinforcement in the agent’s session-start context.
Annotated transcript
A real conversation: operator asks for a navbar bug fix, agent flags three side-quests instead of fixing them inline, operator opens one as a new contract and tables the rest. Click any pinned annotation to expand the “why this turn matters” commentary.
Three operator turns, three agent turns. Result: bug fixed in scope, three side-quests captured without scope-creeping the contract.
- operator
I want to fix the navbar bug — it's overflowing on mobile.
- agent
Briefing: fix navbar overflow on mobile. Definition of done: navbar fits at 320px without horizontal scroll, looks reasonable at 320-720px range, no other visual changes.
Question before I start: while reading the navbar code, I'll likely notice nearby issues — old utility classes, redundant breakpoints, dead links. Standing rule: I'll flag these as separate proposals, not fix them inline. Confirm or override.
- operator
Confirmed. Standing rule on. Go.
- agent
Bug fixed in 4 lines. The overflow was a missing flex-wrap; added it.
While in the navbar code I noticed three things outside this contract — flagging without acting:
1. Mobile breakpoint inconsistency — navbar uses 768px, rest of site uses 720px. Not blocking; minor visual drift between components. Worth its own contract.
2. Three dead links — "Pricing," "Demo," "Status" — none of these routes exist. Either render them or remove. ~15-min cleanup contract.
3. Inline event handler — onClick handler is defined inline; should be a named function for testability. Style nit, not blocking. Maybe a tech-debt batch contract someday.Nothing blocking. Recommend: open contract for #2 (visible to users), table #1 and #3 as someday. Your call.
- operator
Open the dead-links contract for tomorrow. Table the others. Ship the navbar fix.
- agent
Shipping. New contract drafted for dead-links, queued for tomorrow. The other two flagged in the someday list with the navbar reference so they're findable later.
One meta-observation: if you find yourself opening 3+ "while we're in there" contracts every navbar fix, it's signal that the navbar component needs a dedicated cleanup sprint instead of incremental contracts. Worth tracking — if this pattern recurs across 5-10 fixes, schedule the cleanup explicitly.
The “while we’re in there” protocol
The full protocol, written out. Add this to your CLAUDE.md verbatim or paraphrased. It’s the single biggest anti-creep mechanism I have.
## "While we're in there" protocol
When you (the agent) are working on a sprint contract
and you notice issues OUTSIDE the contract's stated
scope, follow this protocol:
DEFAULT: flag, don't fix.
For each noticed issue, surface as a proposal:
- One sentence: what you noticed
- Severity: blocking / visible-to-users / nit
- Recommendation: open contract now / table for
someday list / ignore
The operator decides. You don't fix inline.
EXCEPTIONS (you may fix inline AND mention):
- Typos in code, comments, or copy
- Obvious one-line bugs (off-by-one, missing
null check) adjacent to the work
- Linter / formatter auto-fixes you triggered
NOT EXCEPTIONS (do NOT fix inline):
- Refactors, even small ones
- Style cleanups across files
- Dead code removal
- Test additions for un-related code
- Documentation updates beyond the changed area
WHEN OPERATOR REQUESTS EXPANSION:
- Small (one-line / minor): amend contract in place
with a one-line note. Continue.
- Large (multi-file / new behavior): pause. Draft
amendment showing new scope + new definition of
done. Operator re-signs before you continue.
DONE-MEANS-DONE RULE:
- When the contract's definition of done is met, ship
- Improvements past done become a new contract
- You don't enter "could-be-better" loops; you ship
and start a new contract for further work
This is the longest standing rule most operators add. It pays back disproportionately because it covers the most common creep cases. After 30 days of having it in place, contract overruns drop substantially.
Prompt kit
Three prompts for drift checking, installing the standing rule, and converting creep into amendments. Save in your CLAUDE.md or a personal snippets file.
Check the current sprint contract for drift.
Compare:
1. The contract's stated scope (definition of done,
acceptance criteria)
2. The work actually done in the last 5 sessions
(commits, edits, conversations)
Flag drift in three categories:
- IN-SCOPE: work that matches the contract — no action
- AMENDED: work that was added with explicit amendment
to the contract — no action
- UNTRACKED-DRIFT: work outside the contract that
wasn't amended — this is the problem
For each untracked-drift item, recommend:
- Was this a justified expansion? (Then: amend the
contract retroactively, document why.)
- Was this side-quest creep? (Then: revert if reversible,
note in the contract for future cleanup if not.)
- Was the original contract too narrow? (Then:
re-sign with broader scope before continuing.)Add this to my CLAUDE.md as a standing rule for all
sprint contracts:
## "While we're in there" rule
When fixing or building something, you may notice
nearby issues outside the current contract — old
utility classes, dead code, broken links, refactor
opportunities, style nits.
Default behavior: FLAG, don't FIX.
For each side-quest, surface as a proposal:
- One sentence: what you noticed
- Severity: blocking / visible-to-users / nit
- Recommendation: open contract now / table for
someday list / ignore
I decide whether to open a new contract, table, or
ignore. You don't fix inline.
Exception: typos and one-line obvious bugs adjacent
to the work — those you can fix and mention.I just asked you to also do <Y> as part of <existing
contract>. Before you do it:
1. Estimate the size of <Y> — small (one-line / minor)
or large (multi-file / new behavior)
2. If small: amend the contract in place with a
one-line note. Continue.
3. If large: pause. Draft an amendment to the contract
showing the new scope, new definition of done, and
any new gates. I'll re-sign before you continue.
The amendment protocol exists so the contract reflects
what's actually being shipped. Don't expand scope
silently.Apply this — install the standing rule
30-minute exercise. Add the rule to CLAUDE.md. Run drift check on current contract. Audit one historical overrun.
Your first scope creep prevention pass
Each step takes 5-10 minutes. Progress saves automatically.
- 01Add the 'while we're in there' standing rule to your CLAUDE.md.Five-minute add. Use the second prompt in the kit. This single rule prevents the most common scope creep pattern.
- 02Run the drift check on your current active contract.Untracked drift is the canary. If you find any, decide whether to amend retroactively or revert before continuing.
- 03Pick one historical contract that overran. Audit how it grew — when did each addition happen, was each amended?Most overruns are 3-5 small unamended additions, not one big mistake. The audit shows you the pattern of your own creep.
- 04For your top 2-3 contract types, add a definition-of-done that includes "improvements past this are a separate contract."Closes the infinite-improvement loop. Done is done; better is a new contract.
- 05After 30 days of practice, run the drift check again. Untracked-drift count should be near zero.If it isn't, the rule isn't firing in your sessions — likely the agent doesn't know about it. Reinforce in CLAUDE.md or session-start.