Feature Sunset Plan

Feature Sunset Plan Skill

Products are good at shipping and terrible at unshipping: features limp on for years because nobody owns the removal, and when a kill finally happens it's announced badly, migrates nobody, and leaves the code behind anyway. A sunset is a product launch in reverse — it deserves the same rigour. This skill plans the whole arc, decision to deletion.

What This Skill Produces

• A decision record: why this feature dies, the evidence, and what was considered instead
• An affected-user analysis — who actually uses it, how deeply, and who screams
• Migration paths per user segment, with the no-path-exists cases faced honestly
• A staged timeline with comms per stage, and the removal checklist that ends in deleted code

Required Inputs

Ask for (if not already provided):

• The feature and the evidence for killing it: usage data (who/how many/how deeply — depth matters more than counts), cost to maintain, what it blocks
• The user reality: any contractual commitments, enterprise customers with it in their workflow, data users have stored in it
• What replaces it — an internal alternative, a competitor hand-off, or honestly nothing
• Constraints: renewal cycles to respect, compliance data-retention duties, support capacity for the transition

Sunset Method

1. Make the kill decision auditable. The decision record states: the evidence (usage, cost, strategy misfit), the alternatives considered (invest, maintain-freeze, spin off), and the success criteria for the sunset itself (support tickets contained under X, churn attributable under Y, code deleted by date Z). A sunset without success criteria drifts back into maintenance.
2. Analyse users by depth, not count. "2% use it" hides the enterprise account whose workflow depends on it. Segment: incidental (touched it once — need nothing but the notice) · regular (in their routine — need a migration path) · dependent (built process/data on it — need white-glove handling and account-team involvement before any public notice). Check contracts: a feature named in an enterprise agreement isn't yours to kill on your schedule.
3. Build the migration path per segment. For each: where do they go (the replacement, an export, a partner tool), what carries over automatically vs manually, and what they lose — stated plainly; migration comms that pretend equivalence get caught, and the trust cost exceeds the feature's. Data handling is explicit: export formats, how long data stays retrievable after shutoff, what compliance requires kept, what gets deleted and when.
4. Stage the timeline. The standard arc, compressed or stretched by depth-of-dependence:
   • Soft close — hidden from new users; existing users unaffected (kills growth of the problem)
   • Announce — dependent users first, privately, before the public notice; then in-product notice to actual users of the feature (not a banner for everyone), each with date + path + what-you-lose
   • Freeze — no new data/objects created; reminders escalate
   • Shutoff — read/export-only window
   • Removal — data handled per policy, and the code deleted — flags, dead paths, docs, the SKU in billing Every stage has a date and an owner in the plan.
5. Prepare for the screamers. The loudest resistance often comes from internal teams (the seller who promised it, the founder who built it) and a handful of vocal users. The plan pre-writes: the support macro, the account-team talking points, the exception policy (who may grant extensions, the maximum extension, and the answer to "can we just keep it for this one customer" — which is the question that turns sunsets into zombies).
6. Close the loop. After removal: the retro against the sunset's own success criteria, and the decision + learnings filed (the Brain's decisions/ if one exists) — the next sunset should start smarter.