MoSCoW Prioritization for Salesforce Backlog
This skill activates when a Salesforce delivery team needs to prioritize a backlog of user stories or change requests for a sprint, release, or roadmap horizon. It produces a fixed-shape prioritized backlog: each row carries a MoSCoW tag, an effort tier, a value tier, an optional WSJF tie-break score, a release target, and a one-line rationale. The output is the canonical handoff into the release-train-planner, the orchestrator, and the deployment-risk-scorer agents.
Before Starting
Gather this context before running a prioritization session:
- Is the sponsor or product owner in the room? MoSCoW is a negotiated taxonomy, not a survey. If the person who owns the budget or the business outcome is not present, the output is provisional and must be reviewed before commit.
- Is the sizing convention agreed? This skill assumes the team has already adopted a sizing convention (T-shirt S/M/L/XL, Fibonacci, or person-days). If sizing is contested, stop and resolve that first — MoSCoW without a shared effort signal is theatre.
- Is the team capacity known and stable? Capacity must be expressed in the same unit as effort tiers (e.g., person-days remaining in the sprint after meetings, leave, support rotation). The Must commit is bounded by capacity, not by enthusiasm.
- Is each backlog item written as a Salesforce-ready user story? If stories are vague ("improve case management"), prioritization is meaningless. Refer to
admin/user-story-writing-for-salesforce and finish that first.
Core Concepts
The MoSCoW Rubric
MoSCoW comes from DSDM/Agile Project Framework and forces every backlog item into one of four named buckets. The discipline is in the definitions, not in the act of labelling.
| Bucket |
Meaning |
Effort cap |
What happens if it slips |
| Must have (M) |
Release fails its objective if not delivered: regulator requires it, contractual deadline depends on it, org won't function without it |
DSDM canon: ≤ ~60% of total release effort. Above 60% → overcommitted, at risk |
Release fails — escalate, re-tag, or extend horizon |
| Should have (S) |
Important and high-value, but not release-breaking |
None, but commit cap: Must + Should ≤ ~80% of capacity |
Release ships; stakeholders unhappy. Natural overflow when capacity is tight |
| Could have (C) |
Nice to have. Polish, reporting refinements, minor UX upgrades |
Stretch goals only — fill slack, never commit |
Buffer that absorbs estimate misses on Musts/Shoulds |
| Won't have — this release (W) |
Agreed-out for current horizon; candidate for a future release |
n/a |
Goes back to backlog tagged for re-grooming |
| Won't have — ever (W) |
Permanently out of scope (regulatory, architectural, strategic) |
n/a |
Archive with documented rationale — do not let it ferment |
The most common MoSCoW failure mode is everything-is-Must. If the backlog has more than ~60% Must by effort, the rubric has degraded into a wishlist and the prioritization session has not actually happened.
The Effort + Value Lens
MoSCoW alone is a coarse signal. Pair every item with two orthogonal scales so the team can sort within a bucket and detect cheap wins:
Effort tier (S/M/L/XL):
| Tier |
Indicative scope |
| S |
Half a day or less (a field, a list view, a permission set tweak) |
| M |
One to three days (a record-triggered flow, a small report bundle, a validation rule pack) |
| L |
Three to ten days (a multi-object flow, a Lightning page redesign, an Apex trigger refactor) |
| XL |
More than ten days (a new object model, an integration, a Lightning component suite). XL items in a sprint are a smell — split. |
Value tier (1–5): business value as judged by the sponsor.
| Tier |
Indicative business value |
| 5 |
Strategic; tied to a board-level OKR or a regulatory deadline |
| 4 |
High; closes a meaningful pain point or unlocks revenue |
| 3 |
Solid; clear ROI but not strategic |
| 2 |
Incremental; small productivity gain |
| 1 |
Cosmetic; gold-plating |
The (effort, value) pair is the crucial second signal. A "Must, XL, value 2" row is almost certainly miscategorized and should be challenged.
WSJF as the Tie-Break
When MoSCoW + effort + value still produce ties — typically a cluster of "Must, M, value 4" items competing for the same sprint slot — escalate to WSJF (Weighted Shortest Job First) from SAFe:
WSJF = Cost of Delay / Job Size
Cost of Delay = User-Business Value + Time Criticality + Risk Reduction / Opportunity Enablement
Each component is scored on the modified Fibonacci 1, 2, 3, 5, 8, 13. Job Size uses the same scale (or the team's existing effort points). Sort descending: highest WSJF wins the slot.
WSJF is a tie-break, not a replacement for MoSCoW. Do not rank the entire backlog by WSJF — the cognitive cost is high and the comparative scoring degrades quickly past 15–20 items.
The Release Commit Rule
Once items are tagged, commit them to a release or sprint with this rule:
- Sum of Must effort ≤ team capacity for the horizon
- Sum of Must + Should effort ≤ ~80% of capacity (leaves slack for estimate misses and unplanned support)
- Could items fill any remaining slack but are explicitly stretch goals, not commitments
If Must alone exceeds capacity, the prioritization is invalid: either capacity must be raised (more people, longer horizon) or items must be re-tagged. The stalemate is the signal — do not paper over it by promising and missing.
Common Patterns
Pattern: Capacity-Bounded Sprint Commit
When to use: Two-week sprints with a stable team.
How it works:
- Compute capacity: (team size × sprint days) − (leave + support rotation + ceremonies). Express in the team's effort unit.
- Tag every backlog candidate M/S/C/W with rationale.
- Attach effort tier and value tier to every M and S item (W and C items can be effort-tagged later).
- Sum Must effort. If > capacity, escalate to the sponsor: cut, defer, or raise capacity.
- Sum Must + Should effort. Cap at ~80% of capacity. The remainder is the Could stretch zone.
- Record
release_target for every committed row; set Won't-this-release rows to the next horizon and Won't-ever rows to archived.
Why not just the top-N stories: Top-N ignores effort. Six "value 5, XL" items overcommit a sprint that easily holds twelve "value 4, S" items.
Pattern: WSJF Tie-Break Workshop
When to use: When MoSCoW labelling produces a cluster of indistinguishable Musts that exceed sprint capacity.
How it works:
- Pull only the tied cluster into a worksheet (typically 5–15 rows).
- For each row, score: User-Business Value (1–13), Time Criticality (1–13), Risk Reduction / Opportunity Enablement (1–13), Job Size (1–13).
- Compute WSJF = (UBV + TC + RR/OE) / JS.
- Sort descending. The top items take the available slots; the rest become Should-have for the next horizon.
- Persist the score in the row's
wsjf_score column so the rationale is auditable.
Why not skip WSJF and just argue: Argument scales badly past three people. WSJF gives the team a shared rubric; the score is the artefact, not the verdict.
Decision Guidance
| Situation |
Recommended Approach |
Reason |
| Backlog has >60% Must by effort |
Stop and re-tag — the rubric has collapsed |
Everything-is-Must means nothing is prioritized |
| Item is regulatory or contractually due this release |
Must, value 5, with effort tier |
Regulatory deadlines are non-negotiable but still need sizing |
| Sponsor cannot decide between two Musts of equal effort |
Run WSJF on just the tied pair |
Tie-break with a shared rubric beats arguing |
| Item has been Won't for three releases running |
Reclassify Won't-ever and archive |
Stale Won't items pollute backlog grooming sessions |
| Effort estimate is XL |
Split the story before prioritizing |
XL items hide complexity; they distort capacity math |
| Item is "nice UX polish" |
Could, value 1–2 |
Polish is the buffer, not the commitment |
| Stakeholder wants Should re-tagged as Must mid-sprint |
Reject — process churn is the larger cost |
Re-prioritizing every sprint destroys throughput |
Recommended Workflow
Step-by-step instructions for an AI agent or practitioner activating this skill:
- Ingest the backlog — load every candidate as a row; verify each row has a story_id and a description sufficient to judge value and effort. Reject rows that are not real user stories.
- Tag MoSCoW — assign M / S / C / W to every row with a one-line rationale. Won't rows must be sub-tagged Won't-this-release vs Won't-ever.
- Attach effort tier — assign S / M / L / XL to every M and S row. Flag XL items for splitting before they are committed.
- Attach value tier — assign 1–5 to every M and S row, validated with the sponsor.
- WSJF tie-break — for any cluster of Musts that exceeds sprint capacity, score Cost of Delay / Job Size and persist
wsjf_score.
- Commit Must to the current sprint or release — verify Sum(Must effort) ≤ capacity and Sum(Must+Should) ≤ ~80% of capacity. Set
release_target for every committed row.
- Re-prioritize at backlog grooming — refresh tags only at the agreed grooming cadence (typically every two sprints). Avoid mid-sprint churn.
Handoff Schema
Every prioritized backlog row produced by this skill MUST conform to this JSON shape so downstream agents (release-train-planner, orchestrator, deployment-risk-scorer) can consume it:
{
"story_id": "STORY-1234",
"moscow": "M",
"moscow_subtag": null,
"effort": "M",
"value": 4,
"wsjf_score": null,
"release_target": "2026-Spring",
"rationale": "Regulator requires audit trail by end of FY26 Q3."
}
moscow — one of M | S | C | W
moscow_subtag — null for M/S/C; for W must be won't-this-release or won't-ever
effort — one of S | M | L | XL
value — integer 1–5
wsjf_score — number, populated only when WSJF tie-break was used; otherwise null
release_target — ISO-style release identifier or backlog (Won't-this-release) or archived (Won't-ever)
rationale — one sentence; required for every W row, recommended for every M row
The canonical table form lives in templates/moscow-prioritization-for-sf-backlog-template.md.
Review Checklist
Run through these before handing the prioritized backlog to delivery:
Salesforce-Specific Gotchas
Non-obvious behaviours that cause real prioritization failures on Salesforce projects:
- Regulatory Musts that aren't actually Must — "Compliance wants it" is not the same as "the regulator will fine us if we don't ship by date X". Force a citation: which regulation, which clause, which deadline. Otherwise it goes Should.
- Won't-this-release ferments into Won't-ever silently — A row tagged Won't-this-release for four consecutive grooming cycles is no longer being deferred; it is being declined. Surface it for a real archive decision.
- Capacity inflated by counting full FTEs — A two-week sprint with five admins ≠ 50 admin-days. Subtract leave, support rotation, ceremonies, code review, and UAT participation. Real capacity is typically 50–60% of nominal.
- MoSCoW without effort hides infeasibility — A backlog of 80 Musts feels confident until the team realizes Must alone is 200 days of work for a 40-day sprint. Always pair MoSCoW with effort.
- Mid-sprint re-prioritization — Stakeholders frequently ask to swap a Must in once a sprint starts. The cost of churn (context switching, partial work abandoned, retests) is almost always higher than the cost of waiting one sprint.
Output Artifacts
| Artifact |
Description |
| Prioritized backlog table |
One row per story with story_id, moscow, effort, value, wsjf_score, release_target, rationale |
| Sprint or release commit list |
The Must subset whose effort sum is within team capacity |
| Won't list (split) |
Won't-this-release rows (return to backlog) vs Won't-ever rows (archived) with rationale |
| WSJF tie-break worksheet |
For tied Must clusters: UBV, Time Criticality, RR/OE, Job Size, computed WSJF |
Related Skills
admin/user-story-writing-for-salesforce — author the stories before prioritizing them
admin/requirements-gathering-for-sf — finish discovery before tagging MoSCoW
agents/release-train-planner/AGENT.md — consumes the prioritized backlog to plan releases
agents/orchestrator/AGENT.md — uses the release_target and effort signal to schedule which agents run when
1---2name: moscow-prioritization-for-sf-backlog3description: "Use this skill when prioritizing a Salesforce backlog with the MoSCoW method (Must / Should / Could / Won't) plus an effort + value lens, deciding what fits in the next sprint or release, and using WSJF as a tie-break when MoSCoW alone produces ties. Trigger keywords: MoSCoW prioritization, must should could won't, WSJF salesforce, prioritize salesforce stories, sprint commit, backlog grooming. NOT for story writing or splitting (use admin/user-story-writing-for-salesforce). NOT for release train planning (use agents/release-train-planner). NOT for sizing/estimation method debates — this skill assumes a sizing convention is already in place."4category: admin5salesforce-version: "Spring '25+"6well-architected-pillars:7 - Operational Excellence8 - Reliability9triggers:10 - "how do I MoSCoW prioritize a Salesforce backlog must should could won't"11 - "prioritize salesforce stories must should could when capacity is fixed"12 - "WSJF salesforce tie break when too many stories are tagged Must"13 - "what does Won't mean in MoSCoW for a Salesforce release"14 - "how to commit must-haves to a Salesforce sprint without overcommitting"15 - "MoSCoW backlog grooming for a salesforce admin team"16 - "effort and value tiers for prioritizing a Salesforce backlog"17tags:18 - moscow-prioritization19 - backlog-management20 - wsjf21 - sprint-planning22 - business-analysis23inputs:24 - "Backlog of user stories or work items with story IDs and short descriptions"25 - "Team capacity for the target sprint or release (in story points or person-days)"26 - "Sizing convention already adopted by the team (T-shirt, Fibonacci, person-days)"27 - "Sponsor or product owner availability for the prioritization session"28outputs:29 - "Prioritized backlog table: story_id, moscow, effort, value, wsjf_score, release_target, rationale"30 - "Sprint or release commit list (Must items totalling within capacity)"31 - "Won't list with each row tagged Won't-this-release vs Won't-ever and rationale"32 - "WSJF tie-break worksheet for items where MoSCoW alone produced ties"33dependencies: []34version: 1.0.035author: Pranav Nagrecha36updated: 2026-04-2837metadata:38 source: https://skillmd.com/skills/pranavnagrecha/moscow-prioritization-for-sf-backlog39---4041# MoSCoW Prioritization for Salesforce Backlog4243This skill activates when a Salesforce delivery team needs to prioritize a backlog of user stories or change requests for a sprint, release, or roadmap horizon. It produces a fixed-shape prioritized backlog: each row carries a MoSCoW tag, an effort tier, a value tier, an optional WSJF tie-break score, a release target, and a one-line rationale. The output is the canonical handoff into the release-train-planner, the orchestrator, and the deployment-risk-scorer agents.4445---4647## Before Starting4849Gather this context before running a prioritization session:5051- **Is the sponsor or product owner in the room?** MoSCoW is a negotiated taxonomy, not a survey. If the person who owns the budget or the business outcome is not present, the output is provisional and must be reviewed before commit.52- **Is the sizing convention agreed?** This skill assumes the team has already adopted a sizing convention (T-shirt S/M/L/XL, Fibonacci, or person-days). If sizing is contested, stop and resolve that first — MoSCoW without a shared effort signal is theatre.53- **Is the team capacity known and stable?** Capacity must be expressed in the same unit as effort tiers (e.g., person-days remaining in the sprint after meetings, leave, support rotation). The Must commit is bounded by capacity, not by enthusiasm.54- **Is each backlog item written as a Salesforce-ready user story?** If stories are vague ("improve case management"), prioritization is meaningless. Refer to `admin/user-story-writing-for-salesforce` and finish that first.5556---5758## Core Concepts5960### The MoSCoW Rubric6162MoSCoW comes from DSDM/Agile Project Framework and forces every backlog item into one of four named buckets. The discipline is in the definitions, not in the act of labelling.6364| Bucket | Meaning | Effort cap | What happens if it slips |65|---|---|---|---|66| **Must have (M)** | Release fails its objective if not delivered: regulator requires it, contractual deadline depends on it, org won't function without it | DSDM canon: ≤ ~60% of total release effort. Above 60% → overcommitted, at risk | Release fails — escalate, re-tag, or extend horizon |67| **Should have (S)** | Important and high-value, but not release-breaking | None, but commit cap: Must + Should ≤ ~80% of capacity | Release ships; stakeholders unhappy. Natural overflow when capacity is tight |68| **Could have (C)** | Nice to have. Polish, reporting refinements, minor UX upgrades | Stretch goals only — fill slack, never commit | Buffer that absorbs estimate misses on Musts/Shoulds |69| **Won't have — this release (W)** | Agreed-out for current horizon; candidate for a future release | n/a | Goes back to backlog tagged for re-grooming |70| **Won't have — ever (W)** | Permanently out of scope (regulatory, architectural, strategic) | n/a | Archive with documented rationale — do not let it ferment |7172The most common MoSCoW failure mode is everything-is-Must. If the backlog has more than ~60% Must by effort, the rubric has degraded into a wishlist and the prioritization session has not actually happened.7374### The Effort + Value Lens7576MoSCoW alone is a coarse signal. Pair every item with two orthogonal scales so the team can sort within a bucket and detect cheap wins:7778**Effort tier (S/M/L/XL):**7980| Tier | Indicative scope |81|---|---|82| S | Half a day or less (a field, a list view, a permission set tweak) |83| M | One to three days (a record-triggered flow, a small report bundle, a validation rule pack) |84| L | Three to ten days (a multi-object flow, a Lightning page redesign, an Apex trigger refactor) |85| XL | More than ten days (a new object model, an integration, a Lightning component suite). XL items in a sprint are a smell — split. |8687**Value tier (1–5):** business value as judged by the sponsor.8889| Tier | Indicative business value |90|---|---|91| 5 | Strategic; tied to a board-level OKR or a regulatory deadline |92| 4 | High; closes a meaningful pain point or unlocks revenue |93| 3 | Solid; clear ROI but not strategic |94| 2 | Incremental; small productivity gain |95| 1 | Cosmetic; gold-plating |9697The (effort, value) pair is the crucial second signal. A "Must, XL, value 2" row is almost certainly miscategorized and should be challenged.9899### WSJF as the Tie-Break100101When MoSCoW + effort + value still produce ties — typically a cluster of "Must, M, value 4" items competing for the same sprint slot — escalate to WSJF (Weighted Shortest Job First) from SAFe:102103```104WSJF = Cost of Delay / Job Size105Cost of Delay = User-Business Value + Time Criticality + Risk Reduction / Opportunity Enablement106```107108Each component is scored on the modified Fibonacci 1, 2, 3, 5, 8, 13. Job Size uses the same scale (or the team's existing effort points). Sort descending: highest WSJF wins the slot.109110WSJF is a tie-break, not a replacement for MoSCoW. Do not rank the entire backlog by WSJF — the cognitive cost is high and the comparative scoring degrades quickly past 15–20 items.111112### The Release Commit Rule113114Once items are tagged, commit them to a release or sprint with this rule:115116- **Sum of Must effort ≤ team capacity for the horizon**117- **Sum of Must + Should effort ≤ ~80% of capacity** (leaves slack for estimate misses and unplanned support)118- **Could items fill any remaining slack** but are explicitly stretch goals, not commitments119120If Must alone exceeds capacity, the prioritization is invalid: either capacity must be raised (more people, longer horizon) or items must be re-tagged. The stalemate is the signal — do not paper over it by promising and missing.121122---123124## Common Patterns125126### Pattern: Capacity-Bounded Sprint Commit127128**When to use:** Two-week sprints with a stable team.129130**How it works:**1311. Compute capacity: (team size × sprint days) − (leave + support rotation + ceremonies). Express in the team's effort unit.1322. Tag every backlog candidate M/S/C/W with rationale.1333. Attach effort tier and value tier to every M and S item (W and C items can be effort-tagged later).1344. Sum Must effort. If > capacity, escalate to the sponsor: cut, defer, or raise capacity.1355. Sum Must + Should effort. Cap at ~80% of capacity. The remainder is the Could stretch zone.1366. Record `release_target` for every committed row; set Won't-this-release rows to the next horizon and Won't-ever rows to `archived`.137138**Why not just the top-N stories:** Top-N ignores effort. Six "value 5, XL" items overcommit a sprint that easily holds twelve "value 4, S" items.139140### Pattern: WSJF Tie-Break Workshop141142**When to use:** When MoSCoW labelling produces a cluster of indistinguishable Musts that exceed sprint capacity.143144**How it works:**1451. Pull only the tied cluster into a worksheet (typically 5–15 rows).1462. For each row, score: User-Business Value (1–13), Time Criticality (1–13), Risk Reduction / Opportunity Enablement (1–13), Job Size (1–13).1473. Compute WSJF = (UBV + TC + RR/OE) / JS.1484. Sort descending. The top items take the available slots; the rest become Should-have for the next horizon.1495. Persist the score in the row's `wsjf_score` column so the rationale is auditable.150151**Why not skip WSJF and just argue:** Argument scales badly past three people. WSJF gives the team a shared rubric; the score is the artefact, not the verdict.152153---154155## Decision Guidance156157| Situation | Recommended Approach | Reason |158|---|---|---|159| Backlog has >60% Must by effort | Stop and re-tag — the rubric has collapsed | Everything-is-Must means nothing is prioritized |160| Item is regulatory or contractually due this release | Must, value 5, with effort tier | Regulatory deadlines are non-negotiable but still need sizing |161| Sponsor cannot decide between two Musts of equal effort | Run WSJF on just the tied pair | Tie-break with a shared rubric beats arguing |162| Item has been Won't for three releases running | Reclassify Won't-ever and archive | Stale Won't items pollute backlog grooming sessions |163| Effort estimate is XL | Split the story before prioritizing | XL items hide complexity; they distort capacity math |164| Item is "nice UX polish" | Could, value 1–2 | Polish is the buffer, not the commitment |165| Stakeholder wants Should re-tagged as Must mid-sprint | Reject — process churn is the larger cost | Re-prioritizing every sprint destroys throughput |166167---168169## Recommended Workflow170171Step-by-step instructions for an AI agent or practitioner activating this skill:1721731. **Ingest the backlog** — load every candidate as a row; verify each row has a story_id and a description sufficient to judge value and effort. Reject rows that are not real user stories.1742. **Tag MoSCoW** — assign M / S / C / W to every row with a one-line rationale. Won't rows must be sub-tagged Won't-this-release vs Won't-ever.1753. **Attach effort tier** — assign S / M / L / XL to every M and S row. Flag XL items for splitting before they are committed.1764. **Attach value tier** — assign 1–5 to every M and S row, validated with the sponsor.1775. **WSJF tie-break** — for any cluster of Musts that exceeds sprint capacity, score Cost of Delay / Job Size and persist `wsjf_score`.1786. **Commit Must to the current sprint or release** — verify Sum(Must effort) ≤ capacity and Sum(Must+Should) ≤ ~80% of capacity. Set `release_target` for every committed row.1797. **Re-prioritize at backlog grooming** — refresh tags only at the agreed grooming cadence (typically every two sprints). Avoid mid-sprint churn.180181---182183## Handoff Schema184185Every prioritized backlog row produced by this skill MUST conform to this JSON shape so downstream agents (release-train-planner, orchestrator, deployment-risk-scorer) can consume it:186187```json188{189 "story_id": "STORY-1234",190 "moscow": "M",191 "moscow_subtag": null,192 "effort": "M",193 "value": 4,194 "wsjf_score": null,195 "release_target": "2026-Spring",196 "rationale": "Regulator requires audit trail by end of FY26 Q3."197}198```199200- `moscow` — one of `M | S | C | W`201- `moscow_subtag` — null for M/S/C; for W must be `won't-this-release` or `won't-ever`202- `effort` — one of `S | M | L | XL`203- `value` — integer 1–5204- `wsjf_score` — number, populated only when WSJF tie-break was used; otherwise null205- `release_target` — ISO-style release identifier or `backlog` (Won't-this-release) or `archived` (Won't-ever)206- `rationale` — one sentence; required for every W row, recommended for every M row207208The canonical table form lives in `templates/moscow-prioritization-for-sf-backlog-template.md`.209210---211212## Review Checklist213214Run through these before handing the prioritized backlog to delivery:215216- [ ] Every row has a MoSCoW tag (M/S/C/W) — no nulls217- [ ] Every Won't row has a sub-tag (Won't-this-release vs Won't-ever) and a rationale218- [ ] Every Must and Should row has effort and value tiers219- [ ] Sum of Must effort ≤ team capacity for the target horizon220- [ ] Sum of Must + Should effort ≤ ~80% of capacity221- [ ] Must items account for ≤ ~60% of backlog effort222- [ ] No XL items in the sprint commit (split first)223- [ ] WSJF was applied wherever Musts tied at the capacity boundary224- [ ] Sponsor or product owner signed off in the prioritization session225- [ ] Won't-ever rows have been archived, not left in the active backlog226227---228229## Salesforce-Specific Gotchas230231Non-obvious behaviours that cause real prioritization failures on Salesforce projects:2322331. **Regulatory Musts that aren't actually Must** — "Compliance wants it" is not the same as "the regulator will fine us if we don't ship by date X". Force a citation: which regulation, which clause, which deadline. Otherwise it goes Should.2342. **Won't-this-release ferments into Won't-ever silently** — A row tagged Won't-this-release for four consecutive grooming cycles is no longer being deferred; it is being declined. Surface it for a real archive decision.2353. **Capacity inflated by counting full FTEs** — A two-week sprint with five admins ≠ 50 admin-days. Subtract leave, support rotation, ceremonies, code review, and UAT participation. Real capacity is typically 50–60% of nominal.2364. **MoSCoW without effort hides infeasibility** — A backlog of 80 Musts feels confident until the team realizes Must alone is 200 days of work for a 40-day sprint. Always pair MoSCoW with effort.2375. **Mid-sprint re-prioritization** — Stakeholders frequently ask to swap a Must in once a sprint starts. The cost of churn (context switching, partial work abandoned, retests) is almost always higher than the cost of waiting one sprint.238239---240241## Output Artifacts242243| Artifact | Description |244|---|---|245| Prioritized backlog table | One row per story with story_id, moscow, effort, value, wsjf_score, release_target, rationale |246| Sprint or release commit list | The Must subset whose effort sum is within team capacity |247| Won't list (split) | Won't-this-release rows (return to backlog) vs Won't-ever rows (archived) with rationale |248| WSJF tie-break worksheet | For tied Must clusters: UBV, Time Criticality, RR/OE, Job Size, computed WSJF |249250---251252## Related Skills253254- `admin/user-story-writing-for-salesforce` — author the stories before prioritizing them255- `admin/requirements-gathering-for-sf` — finish discovery before tagging MoSCoW256- `agents/release-train-planner/AGENT.md` — consumes the prioritized backlog to plan releases257- `agents/orchestrator/AGENT.md` — uses the release_target and effort signal to schedule which agents run when