Mid-sprint scope changes
The amendment protocol that makes scope creep visible.
What an amendment is
Sprint contracts (Operating 01) pre-register what “done” means before any code is written. But work in flight discovers things. New requirements surface. Adjacent fixes are tempting. Real conditions change.
An amendment is a formal addendum to a contract that adds, removes, or modifies criteria mid-sprint. It has the same shape as the contract — trigger, change, new criteria, signatures — and it requires re-signature from both Builder and Evaluator before it’s binding.
The amendment is what keeps mid-sprint scope changes from becoming silent expansions. Without amendments, every contract is a lie within 24 hours.
The story
The first month I ran sprint contracts, I had a 100% amendment-skip rate. Every time the operator surfaced a scope add mid-sprint, the agent absorbed it silently. The contracts looked clean. The actual shipped work was 30-50% larger than the contracts described.
The first time it bit me, evaluation came back saying “all 4 criteria pass.” True — the 4 criteria the contract listed all passed. But the operator had asked for 6 things during the sprint. The 2 unattributed adds also shipped, and one of them broke a thing the contract’s rollback plan didn’t cover.
The fix wasn’t to scold the operator. The fix was to make the agent surface scope adds the moment they happen. Three options: amend, defer, or kill. The operator picks. Either path keeps the contract honest.
Six months in, my amendment rate is roughly one per long sprint. The contract layer stays clean because amendments capture the changes instead of the changes hiding in chat history.
Three ways scope creeps anyway
Even with the amendment protocol, scope can still creep in three patterns. Hover any card to see the diagnosis.
The silent expansion
The verbal pivot
The runaway amendment
The fix in all three: the agent has the responsibility to surface scope adds proactively. The operator is too in-the-flow to remember to amend. The agent isn’t. Build the habit on the agent side.
The amendment test
Run this on any sprint that’s in flight or recently closed. Surfaces silent expansions before they become a problem.
Walk the work since the original contract was signed.
For each piece of work, ask:
- Was this in the original criteria?
- If not, has it been formally amended?
- If neither, it's a silent expansion — the contract is a lie.
Output a list of unattributed work items. For each, propose:
- Amend (write the amendment now)
- Defer (close this sprint, open follow-up)
- Revert (undo the work that wasn't in scope)Walks every piece of shipped work and asks whether it traces to the original contract or a formal amendment.
Output is a list of unattributed work. For each: amend (write it up now), defer (close the sprint, open a new one), or revert (undo work that genuinely shouldn’t have happened).
Run this once per sprint, ideally before evaluation. Catching unattributed work pre-eval is much cheaper than catching it post-merge.
Annotated transcript
A real amendment loop. Operator pivots mid-sprint, agent surfaces the choice, amendment gets drafted and re-signed by the evaluator. Click any pinned annotation under an agent reply to expand the “why this turn matters” commentary.
Three operator turns, three agent turns. Result: clean amendment with re-signature, ~3 minutes total cost.
- operator
Quick thing — while you're in the contact form code, also add a captcha. Should be five minutes.
- agent
That's a scope add. The current contract (sprint-2026-04-30-contact-form) covers form fields, validation, and Netlify Forms wiring. Captcha wasn't in there. Three options: 1. **Amend the contract** to add captcha. I write the amendment block, you sign. Sprint extended by ~30 min. 2. **Defer captcha** to a follow-up sprint. We close this one clean, open a new one tomorrow. 3. **Kill the captcha** — decide it's not needed. Document the decision so it doesn't surface again. Which?
- operator
Amend it. Captcha matters because we'll get bot signups otherwise.
- agent
Drafting the amendment now. I'll add it to the contract under an Amendments section: ``` ## Amendments ### Amendment 1 — 2026-04-30 14:22 **Trigger:** Operator surfaced bot-signup risk; captcha protection deemed necessary before launch. **Change:** Add captcha (hCaptcha or Cloudflare Turnstile) to the form. **New criteria:** - Captcha required to submit. Server-side verification on Netlify function. - Submissions without captcha return 400. **Re-signed:** Builder ✓ | Evaluator ✓ | Planner ✓ ``` Re-sign needed because criteria changed. Want me to send to Beacon for re-signature now or batch it with the next eval?
- operator
Send to Beacon now. Don't want to forget.
- agent
Sent. Beacon's re-signature came back in 90 seconds — they pushed back on "return 400" for missing captcha (suggested 422 instead per HTTP semantics). Updated the criterion to 422, re-sent for sign. Confirmed. Amendment is now live in the contract. The captcha work begins after the form fields are done — sequencing matters because the form needs to exist before it can be captcha-protected.
The amendment block — drop into your contract
Add this section to your sprint-contract template. When mid-sprint changes happen, fill in a numbered entry instead of editing the original criteria.
## Amendments
Track in-flight changes here. Each amendment requires re-signature
from both Builder and Evaluator before it's binding.
### Amendment 1 — YYYY-MM-DD HH:MM
**Trigger:** [Why this came up mid-sprint. One sentence.]
**Change:** [Exact change to criteria, scope, dependencies, or rollback.]
**New criteria added:** (if applicable)
- [Criterion with How-to-test, same format as the contract]
**Criteria removed:** (if applicable)
- [Criterion that was killed, with reason]
**Re-signed:**
- Builder ✓ — YYYY-MM-DD
- Evaluator ✓ — YYYY-MM-DD
- Planner ✓ — YYYY-MM-DD
### Amendment 2 — ...
Rule of thumb: 0-2 amendments per sprint is healthy. 3 amendments is the warning sign. 4+ amendments means the original sprint was misframed — close it, consolidate into a new contract.
Prompt kit
Three prompts for keeping amendments honest. Save in CLAUDE.md or a personal snippets file.
Walk the work since the original contract was signed.
For each piece of work, ask:
- Was this in the original criteria?
- If not, has it been formally amended?
- If neither, it's a silent expansion — the contract is a lie.
Output a list of unattributed work items. For each, propose:
- Amend (write the amendment now)
- Defer (close this sprint, open follow-up)
- Revert (undo the work that wasn't in scope)The operator just asked me to also do <X>.
The current contract is <slug>.
Tell me:
1. Is X in the original criteria? Quote the criterion if yes.
2. If no, is X a natural extension or a real scope-add?
3. If a real add — propose three options: amend, defer, kill.
4. If amend, draft the amendment block ready to insert into the contract.
Don't just absorb the work. Force the choice.My current sprint contract has <N> amendments already.
Read the original objective and all amendments.
Tell me:
- How much of the current scope traces to the original objective?
- How much was added via amendments?
- At what point should we have closed this sprint and started a new one?
If amendments are >50% of current scope, recommend closing the
sprint and consolidating into a new contract.Apply this — audit a recent sprint
15-minute exercise. Audit one sprint. Surface the unattributed work.
Run the amendment test on a real sprint
Each step takes ~3 minutes. Progress saves automatically.
- 01Open your most recent in-flight or recently-closed sprint contract.If you don't have one, do Operating 01 first — sprint contracts are the prereq.
- 02Walk the work that actually shipped (or is in flight) and compare to the original criteria.Anything that doesn't trace back is silent expansion.
- 03For each piece of unattributed work: amend, defer, or revert.Most of the time it's amend. Sometimes you'll find a piece that genuinely shouldn't have been done — revert it.
- 04Add an Amendments section to your sprint-contract template (if not there).Future sprints have the section ready. The friction of adding amendments drops to near zero.
- 05Add a habit: when the operator pivots mid-sprint, the agent says "that's a scope add — amend, defer, or kill?"The protocol only works if the agent surfaces the choice. Build the habit.