agentleFS
Dokkabei97Dokkabei97/forged-claude-code/skills/cpo/scope-cutter/SKILL.md

scope-cutter

Skill2 starsChanged 8 months agoMITView on GitHub

Helps startups cut features to true MVP by identifying the minimum set of capabilities needed to deliver core value. Uses systematic frameworks to separate must-haves from nice-to-haves and prevent scope creep.

We split this skill into the rules it gives an agent

8 rules. About 0 are common, 8 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈8

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Ask the critical question:

    line 42
  2. Distinctive:

    Search (use browser Ctrl+F or simple filter)

    line 73
  3. Distinctive:

    When scope creep is detected:

    line 121
  4. Distinctive:

    Write it down (backlog, not sprint)

    line 122
  5. Distinctive:

    Ask: "Does this help us validate our hypothesis faster?"

    line 123
  6. Distinctive:

    If no → Defer with a specific trigger condition

    line 124
  7. Distinctive:

    If yes → Evaluate against current sprint capacity

    line 125
  8. Distinctive:

    Remove features already in production

    line 149

≈ “Common” is an estimate: at least 1 in 5 of the 308,232 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Scope Cutter - MVP Scoping for Startups

Overview

Ruthlessly cuts features to the true minimum needed to test your core hypothesis. The best MVP is embarrassingly small — but it ships.


1. When to Apply

TriggerBehavior
PRD review with too many featuresGuided scope reduction
"MVP scope", "what to cut"Feature triage workflow
Sprint overcommit detectedEmergency scope reduction
Pre-launch feature list reviewShip/defer/kill classification

2. The Scope Cutting Framework

Step 1: Identify Core Value Proposition

Ask the critical question:

"If your product could only do ONE thing, what would it be?"

This becomes the Core Job — everything else is evaluated against it.

Step 2: Feature Triage (MoSCoW + Startup Twist)

Classify every feature:

CategoryDefinitionStartup Rule
MustProduct is broken without itCannot demo without it
ShouldImportant but workaround existsUsers will ask for it in Week 2
CouldNice-to-have, enhances UXUsers might not even notice
Won'tNot now, maybe laterKill it. No "maybe later" backlog bloat

Step 3: Apply Cutting Rules

The 5 Cutting Questions:

  1. Does it test our core hypothesis? No → Cut
  2. Can users achieve the core job without it? Yes → Cut
  3. Would we learn something new by building it? No → Cut
  4. Can we fake it manually first? Yes → Cut (do it manually)
  5. Does it need to exist at launch? No → Cut

Common "Feels Essential but Isn't" Features:

  • Admin dashboard (use database directly at first)
  • Email notifications (send manually)
  • User settings/preferences (use sensible defaults)
  • Social login (email/password is fine for MVP)
  • Dark mode, i18n, responsive (pick ONE platform)
  • Search (use browser Ctrl+F or simple filter)
  • Analytics dashboard (use GA/Mixpanel directly)
  • Password reset flow (do it via support manually)

Step 4: Output Scope Decision

## Scope Decision: [Feature/Product Name]

### Core Job
> [One sentence: what the product must do]

### Ship (Must Have) — [N] features
- [ ] [Feature] — [why it's essential for core job]
- [ ] [Feature] — [why it's essential for core job]

### Defer (Post-Launch) — [N] features
- [Feature] — [why it can wait] — **Trigger**: [when to build it]
- [Feature] — [why it can wait] — **Trigger**: [when to build it]

### Kill (Won't Build) — [N] features
- ~~[Feature]~~ — [why it's not needed]

### Manual Workarounds
| Instead of Building | Do This Manually |
|---------------------|-----------------|
| Admin dashboard | Direct DB queries |
| Email notifications | Manual emails via Mailchimp |
| User onboarding flow | Personal demo calls |

### Estimated Effort After Cutting
- Before: [X] weeks
- After: [Y] weeks
- Savings: [X-Y] weeks ([percentage]% reduction)

3. Scope Creep Prevention Rules

Red Flags During Development

  • "While we're at it, let's also..."
  • "It would be easy to just add..."
  • "Users might want..."
  • "Competitors have..."
  • "What if we need to..."

Response Protocol

When scope creep is detected:

  1. Write it down (backlog, not sprint)
  2. Ask: "Does this help us validate our hypothesis faster?"
  3. If no → Defer with a specific trigger condition
  4. If yes → Evaluate against current sprint capacity

4. Tool Coordination

ToolPurpose
ReadAnalyze existing PRD/feature list
WriteGenerate scope decision document
GrepSearch for feature references in codebase

5. Boundaries

Will:

  • Challenge every feature against core value proposition
  • Provide concrete "manual workaround" alternatives
  • Quantify effort savings from scope reduction
  • Set clear triggers for when deferred features should be built

Will Not:

  • Make the final cut decision (present analysis, you decide)
  • Remove features already in production
  • Ignore user safety or legal requirements in cutting
  • Suggest cutting core authentication/security features

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

Reviews can't be read right now.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.