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 not | That means | Here it means |
|---|---|---|
| Agency client scope creep | A client adds work to a contract | An agent adds work no requirement asked for |
| Permission or tool creep | An agent gains access it shouldn't have | An agent builds beyond the plan |
| A pip freeze or a code freeze | Locked packages, or no merges before a release | Locked requirements, before any code |
| A read-only test file or a context snapshot | A file the agent can't edit, or saved session state | A 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.
| Step | You write | Who | Gates |
|---|---|---|---|
| 1. Write it big | One line per need | Agent drafts, I read | The split |
| 2. Split | Who, what, how you'd see it | Agent drafts, I read | The freeze |
| 3. Cut code words | Plain lines | Agent drafts, I read | The freeze |
| 4. Freeze | One dated yes | Me | Every later step |
| 5. Won't do | Rows with a why | Agent drafts, I approve | Extras |
| 6. Done When | One box per line | Agent drafts, I approve | The end |
| 7. Cite | Design pieces citing lines | Agent, checked | The build |
| 8. Journeys | Tests quoting lines | Testing agent | Acceptance |
| 9. Walk Done When | Boxes against what shipped | Agent checks, I decide | The 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:
| Line | What | How you'd see it |
|---|---|---|
| R-4.1 | A lost station ends the job clearly | If the station goes offline mid-job, the job ends within 3 minutes with the reason "station lost" |
| R-4.2 | A restarted station ends the job clearly | If the station restarts for an update mid-job, the job ends within 3 minutes with the reason "station restarted" |
| R-4.3 | No double print | A station that comes back never prints that job again; the job history shows one attempt |
| R-4.4 | Retry, once | With 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.

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.

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.

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 do | Why |
|---|---|
| Fernhill-hosted stations | A later plan |
| A station marketplace | A later plan |
| Move a job to another station halfway | R-4: a lost job ends |
| More than one retry per lost job | R-4.4 caps it at one |
| Printing from phones | A 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 when | During the build |
|---|---|
| R-4.1: a lost station ends the job within 3 minutes | Empty |
| R-4.4: retry runs exactly one more attempt | Empty |
| R-2.2: the job page names the station it printed on | Empty |
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 piece | Cites |
|---|---|
| The part that spots a lost station | R-4.1, R-4.2 |
| The station app | R-1.3, R-4.1 |
| Job history | R-2.2, R-4.3 |
| Job resume | Nothing |
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.

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.

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.
| Gap | Line | Kind |
|---|---|---|
| The job page shows no label for the reason "station restarted" | R-4.2 | Fix |
| A station renamed mid-job: does the history keep its old name? | R-2.2 | My 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
Write it big in the initiative
Write one requirement per thing a person needs, each with its who.
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.
Cut the code words
Remove endpoints, tables and classes, so a non-coder can read every line.
Freeze the list with an explicit yes
Freeze the list with your explicit yes; from then on only you change it, by re-approval.
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.
Write the Done-When list
Write one Done-When box per requirement: the end of the plan.
Make every design piece cite a requirement
Point every design piece at the requirement it serves, and cut any piece that cites none.
Write one test journey per requirement
Write one test journey per requirement tested live, quoting it word for word.
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.
