Skip to content
Shell
4.1 KB
Raw Blame

SCOPING.md

How to Scope Ruthlessly Without Killing Value

The art of shipping is the art of cutting.


The Scoping Mindset

Every feature has a cost:

  • Time to build
  • Time to maintain
  • Complexity added
  • Surface area for bugs
  • Cognitive load on users

Most features aren't worth it. The ones that are? Ship those.


The Core Question

For every feature, ask:

"If we shipped without this, would anyone notice? Would it matter?"

If the answer is "probably not" - cut it.


The MoSCoW Method (Modified)

Must Have

  • Without this, the product doesn't work
  • Users literally cannot accomplish the core task
  • Be ruthless here - most "musts" are actually "shoulds"

Should Have

  • Significant value, but product functions without it
  • First candidates for v1.1

Could Have

  • Nice to have
  • Build if time permits (it won't)

Won't Have (This Time)

  • Explicitly out of scope
  • Write it down so you don't relitigate

Scoping Questions

Is This Core?

User Goal: [What they're trying to accomplish]
Core Path: [Minimum steps to accomplish it]

Does this feature serve the core path?
- Yes → Consider keeping
- No → Cut or defer

The 80/20 Check

80% of value comes from 20% of features.

Ask:

  • Which 20% of planned features deliver 80% of value?
  • Build those. Defer the rest.

The Fake Launch Test

Imagine launching tomorrow with only what's built today.

  • What would break? (Must have)
  • What would disappoint? (Should have)
  • What wouldn't anyone notice? (Cut it)

Common Scope Traps

"While We're In There..."

Trap: Adding features because you're already touching that code. Reality: Each addition compounds. Stay focused. Rule: If it's not on the list, it doesn't go in this PR.

"Users Might Want..."

Trap: Building for imaginary users with imaginary needs. Reality: You don't know what users want until they use it. Rule: Ship, watch, learn, then build.

"It's Just a Small Thing..."

Trap: Small things add up to big delays. Reality: 10 "small things" = 1 big thing you didn't plan for. Rule: Small things go in the backlog like everything else.

"We'll Need This Eventually..."

Trap: Building for future needs that may never come. Reality: Requirements change. Future you has more information. Rule: Build for now. Refactor when "eventually" becomes "now."

"The Right Way..."

Trap: Over-engineering for elegance. Reality: Working > perfect. Ship teaches you what "right" means. Rule: Do it the simple way first. Refactor when you feel pain.


Deferral Strategies

Not everything needs to be cut - some things just need to wait.

The Stub Strategy

Build the interface, stub the implementation.

function advancedFeature() {
  // TODO: v1.1
  return "Coming soon!";
}

Ship with the hook. Fill in later.

The Manual Strategy

Don't automate what can be done manually at low volume.

  • 10 users? Handle edge cases manually.
  • 1000 users? Now automate.

The Waitlist Strategy

Show the feature exists, but gate access.

  • Validates demand
  • Buys time to build
  • Creates urgency

Scope Documentation

For each project, maintain:

## [Project] Scope Definition

### v1.0 - MVP (Ship Date: X)
Must Have:
- [ ] Feature A
- [ ] Feature B

Should Have (if time):
- [ ] Feature C

### v1.1 - Fast Follow
- [ ] Feature D
- [ ] Feature E

### Backlog (Maybe Never)
- Feature F
- Feature G

### Explicitly Out of Scope
- Feature H (reason: ...)
- Feature I (reason: ...)

The Scope Conversation

When Eddie proposes a feature, the Sr Dev response:

  1. Acknowledge: "That's a good idea."
  2. Locate: "Is this v1, v1.1, or backlog?"
  3. Challenge: "What breaks if we ship without it?"
  4. Decide: Add to appropriate list, move on.

Don't debate. Categorize. Keep moving.


Remember

"Shipping is a feature. The most important one."

  • Unshipped code helps no one
  • Perfect is the enemy of shipped
  • You learn more from users than from planning
  • Scope will always grow; your job is to prune

The goal isn't to build everything. It's to build the right things, and ship them.