1. Home
  2. Blog
  3. Prioritization
  4. Feature creep got faster: coding agents say yes to everything
Prioritization

Feature creep got faster: coding agents say yes to everything

Coding agents removed the cost that used to stop scope from growing. How to put the limit back in the prompt, the plan and the diff.

Feature creep got faster: coding agents say yes to everything
On this page
  1. Why coding agents remove the brake on scope
  2. Know where creep comes from in an agent session
  3. Put the limit in the prompt
  4. Read the plan before any code exists
  5. Check the diff for scope, then for correctness
  6. Say no to your own ideas the same way
  7. Doing this in MindBacklog
  8. Questions

Feature creep is scope that grows past the problem a feature was meant to solve. Coding agents make it faster, because one more addition now costs a prompt instead of a week, and the agent often adds things on its own. The fix is to put the limit in writing: one problem per session, must-haves that pass or fail, and a list of what’s out of scope.

In short
  • Effort used to cap scope. With an agent, effort is close to zero, so the cap has to be written down.
  • Agents add scope on their own: settings, options and refactors nobody asked for.
  • Give each session one problem, checkable must-haves and an out-of-scope list.
  • Read the plan and the diff for extras before you check that the feature works.

Why coding agents remove the brake on scope

Before agents, every addition had a price you could feel. A settings page meant two days. A second export format meant another sprint. That price made you ask whether each addition was worth the time.

With Claude Code or Cursor, the same additions take minutes, so the question stops coming up. Each one is small, and each one looks harmless on its own.

The cost moved to after the build. Every feature is another screen to support, another state to test and another choice a new user has to understand. It also slows the next change, because the agent has more code to read and more behaviour to preserve.

Know where creep comes from in an agent session

Creep in agent work has four common sources. Each one needs a different check.

SourceWhat it looks likeThe check
You, mid-session“While you’re in there, also add filters”Write the idea on a later list and keep going
The agentA config option, a settings screen or a new abstraction you didn’t requestAn out-of-scope list, plus a diff review for extras
Every user requestShipping each ask because it only takes an hourCount who has the problem before you prompt
CompetitorsCopying a feature list from a rival’s pricing pageFind which of your users described that problem

The agent row surprises people most. Agents are built to be helpful, and an open-ended prompt invites them to fill gaps with their best guess at a complete feature. That guess is usually bigger than what your users need.

Put the limit in the prompt

For example, a founder building a time-tracking app for small design agencies hears that owners rebuild invoices by hand from tracked hours. She asks her agent for invoicing. The prompt names a feature, so the agent builds a full one.

Instead of

Add invoicing so agencies can bill clients from their tracked hours.

Try

Owners rebuild invoices by hand from tracked hours at month end. Build one draft invoice per client per month from those hours. Nothing else in this session.

In this illustration, the first prompt comes back with tax rates, multiple currencies, a template editor and reminder emails. Each one is reasonable. None was asked for, and all of it now needs maintaining. A fuller version of the second prompt looks like this.

Problem: agency owners rebuild invoices by hand
from tracked hours at month end (5 of 12 agencies).

Build: one draft invoice per client per month.

Must-haves
- Each project appears with its hours and rate
- The owner can edit any line before sending
- Totals match the hours report for that month

Out of scope for this session
- Taxes, currencies, payment links, reminders,
  invoice templates

Stop when the three must-haves pass. If you think
something else is needed, list it at the end
instead of building it.

The last line matters most. It gives the agent somewhere to put its ideas. You still see them, and you decide later with evidence instead of in the moment.

Read the plan before any code exists

Claude Code and Cursor can both plan before they edit. Claude Code’s plan mode reads files and writes a plan, and it blocks edits to your source until you approve. Cursor’s Plan Mode asks clarifying questions, researches the codebase and gives you a plan you can edit. In both tools, Shift+Tab cycles to it.

  1. Ask for a plan first. Give the scoped prompt and let the agent propose the work.
  2. Strike every line that doesn’t serve a must-have. New settings, new tables and refactors outside the feature are the usual ones.
  3. Approve the trimmed plan. The build now starts from your scope instead of the agent’s guess.
  4. Review the diff for extras. Do this before you test the feature, while the change is still small enough to read.
ONE SESSION, ONE PROBLEM
Open-ended prompt
  • Names a feature, not a problem
  • Agent adds settings and options
  • Refactors code nearby
  • Done when it looks done
Scoped prompt
  • One problem in users' words
  • Must-haves that pass or fail
  • A written out-of-scope list
  • Extra ideas listed, not built
A scoped prompt puts back the limit that effort used to set.

Check the diff for scope, then for correctness

A working feature can still carry creep. Run through this list before you merge.

  • Every changed file maps to a must-have
  • No new settings, flags or options you didn’t ask for
  • No new dependency without a stated reason
  • No refactor of code outside the feature
  • Extra ideas sit in the agent’s list, not in the code
Example

Say the agency founder had kept the currency support the agent added. A few weeks later, an agency that bills in two currencies reports totals that don’t match. She now maintains currency code no user asked for, and the fix pulls her away from the problem her users did raise.

Say no to your own ideas the same way

Most creep starts as a good idea at the wrong time. Keep a later list next to your prompts. When an idea arrives mid-session, write it down with the reason you thought of it, then go back to the work.

Review the later list when you choose the next problem. Treat each idea like a user request, and look for who has the problem and how strong their evidence is. The guide to vibe coding without building the wrong thing covers that method end to end.

Note. An out-of-scope list doesn’t say those features are bad. It says each one needs its own evidence and its own session.

See must-haves that keep a session on one problem. A sample Build Pack for a made-up product, with every section’s source.

See a sample Build Pack

Doing this in MindBacklog

In MindBacklog, the Build Pack carries why it matters, who it’s for, the metric, and the must-haves with acceptance criteria. Every section names its source, and the only numbers are counts. It also says what’s already broken and what already exists. Copy it for Claude Code or Cursor, paste a short prompt into Lovable, or let your agent pull it over MCP on the Growth and Scale plans. How the Build Pack works.

Questions

What causes feature creep?

Scope grows when adding something feels cheaper than deciding against it. Common causes are ideas that arrive mid-build, treating every request as a commitment, and no written definition of done. Coding agents add one more: the agent fills gaps in an open-ended prompt with features of its own.

How do you stop a coding agent from adding features you didn’t ask for?

Give it one problem, must-haves that pass or fail and an explicit out-of-scope list. Ask it to list extra ideas instead of building them, and trim its plan before you approve it. Then check the diff for anything that doesn’t map to a must-have.

Is feature creep the same as scope creep?

They overlap. Scope creep usually means a project’s agreed requirements growing after the work starts. Feature creep means a product gaining features beyond what its users need. For a founder working alone with an agent, the cause and the fix are the same.

Aadarsh Bohara

Founder, MindBacklog

Building the product management tool I wish I had. Multiple startup exits. Writing about AI, product strategy, and what it takes to build things people want.

Build what people actually asked for.

Start with an idea, your first users or a live product. Mind drafts; you decide.

No site yet? Start from your idea.

  • 14 days free
  • No card needed
  • Viewers are free

Or look around a sample workspace first. No sign-up.