Skip to content
SearchSubscribe
Expert · Lesson 05 — Scope creep prevention
E05Expert
Expert · Lesson 05● live

Scope creep prevention

The amendment protocol at scale. Refusing “while we’re in there” without becoming an obstacle.

12 min read · 30 min applyprereq: Operating 01, 05 (sprint contracts + amendments)

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.

MoveWhen it firesWhat it does
1. Flag, don’t fixAgent notices nearby issues during in-scope workAgent surfaces side-quests as proposals; doesn’t act inline
2. Amend, don’t expandOperator asks for additions mid-contractSmall additions amended in place; large ones re-sign the contract
3. Done means doneAfter hitting the definition of doneImprovements 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.

№ 01

The helpful side-quest

claim looks like“Operator asks the agent to fix bug X. Agent fixes bug X, also refactors three nearby functions "while we're in there."”
what’s missingThe refactor wasn't briefed. It might be good or bad — but it wasn't gated, reviewed, or scoped. The PR is now twice as large; the bug fix is harder to review; the refactor is harder to revert independently.
the moveThe agent flags the side-quest as a separate proposal. "I noticed three nearby functions could be refactored. That's outside the current contract. Want me to (a) ignore, (b) note for a future contract, or (c) re-sign the current contract to include this?" Three options, operator picks.
№ 02

The infinite improvement loop

claim looks like“Agent ships the feature. Operator says "it works but could be better." Agent revises. Operator says "closer but..." Loop continues for hours.”
what’s missingNo definition of done at the start, so there's no test for stopping. Each round of "could be better" is justified, but cumulatively the work is now 3-5x what it should have been.
the moveDefinition of done in the contract, gate-out at completion. "Done means: passes tests, deploys, hits the test sentence from Lesson 04. Improvements past that are a separate contract." The discipline is to ship at done and start a new contract for further work.
№ 03

The expanding context

claim looks like“Sprint contract says "add feature X." Mid-sprint, operator says "oh and also Y." Then "and Z." By the end the work is 3x the original scope but no one re-signed.”
what’s missingNo amendment protocol. Every "and also" was reasonable in isolation, but the sum is a sprint that overran by 200% and shipped late.
the moveAny addition mid-contract triggers the amendment protocol from Operating 05. Small additions: amend in place with a one-line note. Large additions: re-sign the contract. "And also Y" doesn't count as scope until it's amended or the contract is re-signed.

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.

The drift check
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.

Refusing side-quests on a navbar fix

Three operator turns, three agent turns. Result: bug fixed in scope, three side-quests captured without scope-creeping the contract.

  1. operator

    I want to fix the navbar bug — it's overflowing on mobile.

  2. 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.

  3. operator

    Confirmed. Standing rule on. Go.

  4. 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.

  5. operator

    Open the dead-links contract for tomorrow. Table the others. Ship the navbar fix.

  6. 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.

The drift check
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.)
The 'while we're in there' standing rule
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.
Convert a creep moment into an amendment
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.

0/5
  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
Expert tier · what's next

After this lesson