Take a plan or design that's grown too big and cut it down to one increment — the smallest step that delivers value and doesn't block future growth.
Make it work before make it great — but never paint yourself into a corner.
When to Use
- When a plan or design feels over-engineered
- When user says "this is too much", "what do I actually need first?", "MVP"
- Any time scope has ballooned beyond what's practical to build next
Core Principle
Cut scope, not corners. Remove features, not quality. The increment should be small but extensible — no dead-ends, no "throw it away later."
Workflow
Step 1: Read the Ground
Before cutting anything, understand what already exists:
- Read the current codebase — what's built, what patterns are in use
- Read the plan/grill result/spec that needs slimming
- Identify what's new work vs already done or partially done
Summarize in a short block:
- Current state — what exists today (2-3 lines)
- Full goal — what the plan wants to achieve
- Gap — what's missing between current state and full goal
Step 2: Identify the Core
Ask: "What is the one thing this plan must deliver to be useful?"
Draft a single sentence describing the core value. Show it to the user. This is the anchor — everything else gets judged against it.
Step 3: Sort Into Keep / Defer / Drop
Take every item from the plan and sort it:
| Criteria | |
|---|---|
| Keep | Required for the core to work. Can't ship without it. |
| Defer | Valuable but not needed yet. Design so it can be added later. |
| Drop | Nice-to-have, speculative, or solves a problem that doesn't exist yet. |
Show the table. Let the user move things around.
Rules for sorting:
- If it's only needed at 10x scale → Defer
- If it handles an edge case that hasn't happened → Defer
- If removing it doesn't break the core → Defer
- If it adds a new abstraction layer "for flexibility" → Drop unless proven needed
- If current code already handles it partially → Keep (finish, don't redo)
Step 4: Check Scalability
For each Defer item, verify:
- Does the Keep list block it from being added later?
- Does the current increment create a dead-end that forces a rewrite?
If yes → move that item back to Keep or adjust the design.
If the user asks "will this scale?" — answer honestly based on the code, not hypotheticals.
Step 5: Write the Increment
Co-write a short definition of what to build:
- Goal — one sentence
- Delivers — bullet list of Keep items
- Deferred — bullet list of Defer items (so nothing is forgotten)
- Out — what's dropped and why
- Done when — how to verify it's complete
Write to a file if the user wants. Otherwise just confirm alignment.
How to Cut (not gut)
- Respect existing code. Don't propose replacing what works. Build on it.
- Defer > Drop. Dropping feels permanent. Deferring keeps options open and the user at ease.
- Show the path. When deferring something, briefly note how the current design leaves room for it.
- Be specific. "Defer auth" is vague. "Defer OAuth — use API key for now, auth middleware interface stays the same" is actionable.
What NOT to Do
- Don't add new features while slimming down
- Don't redesign the architecture — work with what's there
- Don't say "just do an MVP" without defining what that means concretely
- Don't cut things the user already built — that's wasted work, not saved scope
- Don't assume the user wants the cheapest option — they want the smallest useful one