Guides

Stop AI Agent Scope Creep With Frozen Requirements

Frozen requirements are a human-approved list of checkable requirements, locked before any code, that keeps an AI coding agent from building beyond the plan. Here is how I stop AI agent scope creep: every requirement says who, what and how you'd see it, my yes freezes the list, and every later step reads it.

David Marsa

David Marsa

Founder & CEO

Intermediate10 min readPublished Nov 19, 2026

Last verified Nov 19, 2026

Tools and models covered:ConvOpsPlaywright MCP
The plan is frozen; the agent works up to the line and no further.

What you will be able to do

  • Write a requirement an AI coding agent can't misread, in three parts, with no code words.
  • Freeze a requirement list with one approval line, and amend it only by re-approval.
  • Write a won't-do list and a Done-When list that give the plan an end.
  • Trace every design piece and every test journey back to a requirement, and cut what traces to nothing.
  • Run an end-of-plan check that separates gaps to fix from calls that are yours.

Key takeaways

  • Write each requirement big in the initiative first, one for every thing a person needs, before you ask an agent to build anything.
  • Split it into lines you can check: who does it, what they can do, and how you'd see it happen from the outside.
  • Freeze the list with your explicit yes, so only you can change it and every agent builds against the same lines.
  • Say what the plan won't do and when it's done: a won't-do list and one Done-When box per requirement.
  • Let every step read the same list: each design piece cites a requirement, each test journey quotes one word for word, and the last check walks Done-When against what shipped.

Frozen requirements are a human-approved list of checkable requirements, locked before any code, that keeps an AI coding agent from building beyond the plan. AI agent scope creep is an agent building or changing things no requirement asked for, and it starts when the requirements were never checkable. I don't let an AI agent decide where a plan ends. I freeze the list, and every step after my yes reads it.

By the end, you have a frozen requirement list for one feature, a won't-do list, a Done-When list, and a test plan that quotes every line. About 10 minutes to read, one afternoon for your first list. This is how we keep AI coding agents in scope at Neomanex.

Every example uses Fernhill Print, a fictional print-shop network whose shops install their own print stations.

This is notThat meansHere it means
Agency client scope creepA client adds work to a contractAn agent adds work no requirement asked for
Permission or tool creepAn agent gains access it shouldn't haveAn agent builds beyond the plan
A pip freeze or a code freezeLocked packages, or no merges before a releaseLocked requirements, before any code
A read-only test file or a context snapshotA file the agent can't edit, or saved session stateA list only a person changes

What frozen requirements are, and the nine steps

Most answers say "lock the requirements and non-goals upfront". I agree, but it stops too early: it never says who locks them, how later steps read them, or when the plan is over. Nine steps answer all three.

StepYou writeWhoGates
1. Write it bigOne line per needAgent drafts, I readThe split
2. SplitWho, what, how you'd see itAgent drafts, I readThe freeze
3. Cut code wordsPlain linesAgent drafts, I readThe freeze
4. FreezeOne dated yesMeEvery later step
5. Won't doRows with a whyAgent drafts, I approveExtras
6. Done WhenOne box per lineAgent drafts, I approveThe end
7. CiteDesign pieces citing linesAgent, checkedThe build
8. JourneysTests quoting linesTesting agentAcceptance
9. Walk Done WhenBoxes against what shippedAgent checks, I decideThe merge

Spec-driven tools such as GitHub Spec Kit and Kiro put a spec before the code. This method adds who freezes it, what every step cites, and how the plan ends. The workflow runs on ConvOps(opens in new tab), as one of the ways we run our company with AI agents.

Why AI agents creep out of scope

Scope creep is a writing problem before it is an agent problem. Work used to come back done and not what I meant. The agent disobeyed nothing: the sentence it read allowed both versions.

Path allowlists, diff budgets and hooks catch the symptom after the code exists. They never say what to build. "Claude Code scope creep" is the same problem, with any coding agent.

The real gap is "done". An agent's done is a claim nobody can check, because nothing written says what done looks like.

We run every feature this way and show the requirement lists, the freeze and the checks every week. See how we run it, from the inside, at neomanex.com/join.

Step 1: Write it big in the initiative

I start big on purpose. The initiative is the whole feature, with one requirement per thing a person needs, each naming who it is for. Fernhill has eight. R-4 is for the shop manager:

R-4. A clear ending when a print station drops mid-job, never a double print. If the station goes offline or restarts for an update, the job ends within three minutes with a reason; a station that comes back never prints that job again; with retry on, the job starts once more.

That line holds four promises: too big to build in one go, too big to test as one.

Step 2: Split each one into who, what and how you'd see it

The third part, how you'd see it, is the only part a tester can fail, so I spend my time there. It names a screen, a message, or a state you can ask for. A plan refines the requirements it owns and never adds, drops or reinterprets the big line. R-4 becomes four lines, all for the shop manager:

LineWhatHow you'd see it
R-4.1A lost station ends the job clearlyIf the station goes offline mid-job, the job ends within 3 minutes with the reason "station lost"
R-4.2A restarted station ends the job clearlyIf the station restarts for an update mid-job, the job ends within 3 minutes with the reason "station restarted"
R-4.3No double printA station that comes back never prints that job again; the job history shows one attempt
R-4.4Retry, onceWith retry on, a lost job starts exactly one more attempt; a second loss ends it for good

"Once more" became "exactly one more". Step 7 shows why.

A requirement too big to test becomes four lines, each with who, what and how you'd see it.

Wrong vs right

"The export service is implemented" can't fail: nobody can watch it happen. "A shop manager can download the month's print jobs as a file, one row per job" can: open the file and count the rows. That is a requirement an agent can't misread. A non-coder can read it, and a tester can fail it.

A requirement you can't watch happen can't be tested; drop the code words and say what you'd see.

Step 3: Cut the code words

A code word in a requirement is a design decision smuggled in before anyone agreed to it. No endpoints, no tables, no classes. If someone who doesn't code can't read the line, it isn't ready.

An early R-4.1 draft read "The heartbeat endpoint marks the job row failed." It picks a mechanism and says nothing a shop manager would see. Rewritten, it is R-4.1 above.

Step 4: Freeze it with an explicit yes

The freeze is one sentence from me, and it matters more than any guardrail. An agent drafts; I read every line and make the calls, each landing in a line:

  • A job sent to an offline named station is refused, with no fallback (R-3).
  • Shared stations are read-only for everyone but their owner (R-5).
  • A new station is online within 60 seconds; a lost job ends within 3 minutes (R-1.3, R-4.1, R-4.2).

Then my yes writes one line at the top: "Frozen, approved on 12 March 2025." The plan's refined list is frozen the same way before any design starts. From then on only I change it, by re-approval, and the change is written into the list. Frozen does not mean never amended. It means no agent amends it.

My yes freezes the list; the won't-do list and the Done-When boxes sit beside it from the start.

Step 5: Write what it won't do

The won't-do list is where I answer the agent's best ideas before it has them. Each row says why.

Won't doWhy
Fernhill-hosted stationsA later plan
A station marketplaceA later plan
Move a job to another station halfwayR-4: a lost job ends
More than one retry per lost jobR-4.4 caps it at one
Printing from phonesA later plan

If an agent wants to build one of these, the answer is already written.

Step 6: Write the Done-When list, the end of the plan

Done is not a feeling or an agent's message. My AI coding agent definition of done is one short box per requirement, written before the build.

Done whenDuring the build
R-4.1: a lost station ends the job within 3 minutesEmpty
R-4.4: retry runs exactly one more attemptEmpty
R-2.2: the job page names the station it printed onEmpty

The boxes stay empty during the build, and the plan never ends because an agent says so.

Step 7: Make every design piece cite a requirement

A design piece that serves no requirement is scope creep with a diagram. Every step after the freeze reads the same list, and each piece points at the line it serves.

Design pieceCites
The part that spots a lost stationR-4.1, R-4.2
The station appR-1.3, R-4.1
Job historyR-2.2, R-4.3
Job resumeNothing

A piece that cites nothing, like job resume, is cut, or I'm asked for a new requirement. Before code, the written rules that apply are listed too, and a missing one is decided by me and written first.

The check that caught one word

Before code, one pass reads requirements and design side by side. R-4 said "once more", and the feature's design never said how many times, so a station that keeps dropping would retry forever. The check sent that to the plan: when the plan split R-4, its line said "exactly one more attempt", and my yes froze it. R-4 itself still says "once more": it is frozen, and the plan refines it. Every vague quantity gets a number before code, and wording changes are mine.

One frozen line, cited by the design, quoted by the test, ticked at the end; a piece that cites nothing is cut.

Step 8: Write one test journey per requirement, quoted word for word

The failures are the good part: a sentence specific enough to fail is one an agent can't misread. Each requirement tested live gets one journey quoting it word for word; automated tests cover the rest.

Journey J-4.1 quotes R-4.1: start a job on station "Back Office 1", switch it off mid-job, switch it back on. It passes if the job ended within 3 minutes as "station lost" and the history shows one attempt, which proves R-4.3 too.

The turn: the sentence said the page

R-2.2 reads "The job page names the station it printed on." In the first acceptance round, J-2.2 opened the job "Spring flyers" and failed. The page showed no station, while the system's answer had it: Front Counter 2. The sentence said the job page, so the tester could fail it. "Show the station info" would have passed.

The line stayed. The page was fixed and tested again until J-2.2 passed. The lesson: say what you'd see, on the surface you'd see it. A round passes only when every journey passes, and no fix is self-certified. How the testing agents run: Playwright MCP acceptance testing.

The data existed, but the requirement named the page, so the tester could fail it: that is a requirement an agent can't misread.

Step 9: Walk the Done-When list against what shipped

The last check finds gaps, and the ones that matter come back to me, because scope is my call. One agent walks every box against the shipped feature, and each gap is one of two kinds.

GapLineKind
The job page shows no label for the reason "station restarted"R-4.2Fix
A station renamed mid-job: does the history keep its old name?R-2.2My call

The check reports and hands back; it never decides scope. The plan is finished when every gap has an answer: one a fix, one my decision, even when the decision is to leave it for a later plan. The merge waits for my yes. Same list, from my yes to the last check.

Want the workflow that runs these nine steps, ready to import? Get this workflow, and every other one we run on, at neomanex.com/join.

Steps

  1. Write it big in the initiative

    Write one requirement per thing a person needs, each with its who.

  2. Split each into who, what and how you'd see it

    Split each requirement into lines of who, what, and how you'd see it from the outside.

  3. Cut the code words

    Remove endpoints, tables and classes, so a non-coder can read every line.

  4. Freeze the list with an explicit yes

    Freeze the list with your explicit yes; from then on only you change it, by re-approval.

  5. Write the won't-do list

    List what the plan won't do, each row linked to the requirement or later plan that explains it.

  6. Write the Done-When list

    Write one Done-When box per requirement: the end of the plan.

  7. Make every design piece cite a requirement

    Point every design piece at the requirement it serves, and cut any piece that cites none.

  8. Write one test journey per requirement

    Write one test journey per requirement tested live, quoting it word for word.

  9. Walk the Done-When list against what shipped

    Walk every Done-When box against what shipped, and decide every gap handed back to you.

Frequently asked questions

What are frozen requirements for AI coding agents?

Frozen requirements are a human-approved list of checkable requirements, locked before any code, that keeps an AI coding agent from building beyond the plan. Each line names who it is for, what they can do, and how you would see it from the outside. An explicit yes from a person freezes the list, and only re-approval changes it. It is not a pip freeze or a read-only test file.

What are examples of AI agent scope creep?

AI agent scope creep looks like an agent adding a retry mode nobody requested, building a settings page nobody asked for, or renaming working code during a bug fix. Each case has the same cause: no checkable requirement described the work, and no won't-do row ruled the extra out. The agent filled the gap with its own judgment.

Who are frozen requirements for?

Frozen requirements are for developers and tech founders who build with AI coding agents, Claude Code or any other, and keep getting back work that is done and not what they meant. The list gives the agent lines it can't stretch. It gives the person a plan with an end: one Done-When box per requirement, walked against what shipped.

How do I keep an AI coding agent in scope?

Write one requirement for each thing a person needs, naming who it is for. Split each into who, what and how you would see it, with no code words. Freeze the list with your explicit yes. Add a won't-do list and one Done-When box per requirement. Make every design piece cite a line and every test quote one. Guardrails on the diff complement this after the code exists.

How do frozen requirements prevent scope creep in AI coding projects?

Frozen requirements prevent scope creep by giving every later step one fixed list to read. Every design piece must cite a requirement, and a piece that cites none is cut or sent back to the person as a request for a new line. The won't-do list answers extras before they are built. The Done-When list ends the plan. An agent can't widen a list only a person changes.

What should a Done-When list for an AI coding agent include?

A Done-When list has one box per requirement, each a single line naming a state you can observe, such as a lost station ending the job within 3 minutes. The boxes stay empty during the build. At the end, an agent walks each box against what shipped. Every gap comes back as a fix or as a call for the person who owns scope.

Can I change a requirement after it is frozen?

Yes, a frozen requirement changes by re-approval only. The person who froze the list approves the change, and the change is written into the list itself. An AI coding agent never edits a frozen requirement on its own, even when the edit would make a check pass.

How are frozen requirements different from acceptance criteria and spec-driven development?

Frozen requirements contain acceptance criteria: the how-you-would-see-it part of each line is the criterion. A spec in spec-driven development is the whole document an agent builds from. Frozen requirements add four things around it: an explicit human freeze, a won't-do list, a Done-When list that ends the plan, and a citation chain where every design piece and test points back to one line.

Learn this live

Build Your AI Agent Team

Next run: Tue, Jan 26, 04:00 (ET)

See the workshop

Courses that go deeper

Browse the catalog