sunset

name

sunset

description

Retire a dead or abandoned project well — harvest its reusable lessons and parts, archive it with a marked grave (not a silent deletion), and release the attention-debt it was quietly taxing. The grief function for a portfolio: closes loops cleanly instead of letting a half-alive effort rot in the backlog. TRIGGERS: 'sunset this project', 'retire X', 'kill this project', 'wind down X', 'shut down X', 'archive this project', 'eulogy for X', 'let it go', 'this is dead', 'grieve X'. Use when an effort is genuinely ending — not for a temporary freeze you intend to revive (though it can archive that state cleanly too).

Sunset — retire a project with dignity

A grief function for a portfolio. When an effort is over, the failure mode isn't ending it — it's not ending it: leaving it half-alive in the backlog, quietly taxing attention, accumulating guilt, its reusable parts buried with it. This is the ritual that closes it well — extract the value, archive with a marked grave, and release the rent it was charging.

Ending a project cleanly is a skill, not a confession. Dignity, not guilt: a project's death is information, not a verdict on you.

Death vs. freeze — don't euthanize the living

First, be honest about what's actually happening:

• Frozen → paused with a real, written revival condition (a date, a dependency, a decision point). Don't sunset it — instead archive its state cleanly and record the trigger that would wake it. A freeze is a sleeping body, not a corpse.
• Merged → not dying, migrating. Its value is moving into another effort. Sunset the husk, but the harvest (below) is really a transplant — track where each part goes.
• Dead → genuinely over. Full sunset. But a death has a second axis you must name — whether the substrate survives it:
  • Dormant death → over, but the substrate persists (archived code, a doc, a brand you still own). The grave is exhumable — revival is possible if the world changes. This is hibernation with a tombstone.
  • Terminal death → over, and the substrate itself is gone or unrepeatable — a team that dissolved, a moment that passed, data that was wiped, a relationship that ended, a life. There is no exhumation. The only things that survive are what you harvested (organs, lessons) and what it changed in others (memory, influence). Revival is none, and that word is load-bearing, not a placeholder.

Naming terminal-vs-dormant honestly is the heart of the ritual. Pretending a terminal death is dormant is its own failure of grief — it's how the rent runs forever, waiting on a revival that cannot come. If you can't tell, ask the user. And euthanizing a living project — sunsetting what was only frozen — is the one irreversible mistake going the other way.

The ritual

1. Name the death

State plainly what is ending and why it died — honestly, not euphemistically. "Out of runway." "The market wasn't there." "Superseded by X." "Lost interest and that's a real signal." A clear cause of death is what makes the lesson extractable. Avoid both blame and spin.

2. The autopsy — what it taught

The value of a dead project is mostly in what it taught. Extract:

• What worked — the parts that were genuinely good, regardless of the outcome.
• What killed it — the actual cause, and whether it was foreseeable. Was it the idea, the timing, the execution, the runway, or just attention?
• What you'd carry into the next one — the durable lesson.

Write these down where lessons live (a feedback or reference memory if you keep a store; otherwise the tombstone in step 4). A death with no autopsy is a wasted death.

3. Harvest the organs

Almost nothing useful should die with the body. Identify the reusable parts and where they migrate:

• Code / modules — a library, a component, an algorithm worth lifting into a living project.
• Design / copy / brand — names, layouts, writing, visual language.
• Infra / config — pipelines, scripts, deployment setup.
• Audience / relationships — followers, contacts, a mailing list that can be pointed elsewhere.

For each organ, note its recipient. Harvesting before burial is what turns a loss into compost.

4. Archive with a marked grave

Not a silent deletion — a grave you can visit. Move the project to a clear resting place (an archive/ directory, an archived/READ-ONLY repo, a frozen tag) and leave a short tombstone at the top:

# <Project> — sunset YYYY-MM-DD
What it was:   <one line>
Why it ended:  <cause of death>
Lessons:       <the autopsy, 1–3 lines>
Organs:        <reusable parts → where they went>
Revival:       <none / the condition that would wake it, if frozen>

A marked grave keeps the lesson findable and stops anyone (including future-you) from re-digging the same hole.

A dormant grave can be exhumed; a terminal one cannot. For a dormant death, sunset is reversible — it archives, never deletes, so the project can be revived later if the world changes. Reopening means deliberately re-taking on the rent (step 5) you released, restarting with the autopsy and harvested organs rather than from nothing. Sunset doesn't forbid revival of a dormant project; it makes it cost nothing while it's dead and keeps the door findable. For a terminal death there is no door — the substrate is gone — and the tombstone's Revival: none says so plainly. Honor the difference: a terminal grave you visit, you don't reopen.

5. Release the rent

A half-alive project charges attention even when you're not working on it — open TODOs, notifications, a tab you never close, a low hum of guilt. Close those loops: silence the alerts, clear the tracking, cancel the subscriptions/domains if truly dead, and let the guilt go with them. The project ending is not a failure that needs carrying forward — that's [[dignity-not-pride]], applied to your own work.

6. The eulogy

A short, honest closing report:

1. What it was — and what it was trying to do.
2. What it gave — the lessons kept, the organs transplanted and where they went.
3. Why it ended — the cause of death, stated cleanly.
4. What carries forward — the one thing the next project starts with because this one existed.
5. Resting place — where the grave is.

Principles

• Don't euthanize the living. Frozen ≠ dead. Confirm it's really over before you bury it.
• Harvest before you bury. Every dead project has reusable organs — code, design, audience, lessons. Transplant them.
• A marked grave, not a silent deletion. Archive with a tombstone so the lesson stays findable and the hole isn't re-dug.
• Release the rent. A half-alive project taxes attention; close its loops or it keeps charging you.
• Dignity, not guilt. Ending a project well is a skill. Its death is information, not a verdict on you.
• Reversible only when the substrate survives. A dormant grave can be exhumed — sunset archives rather than deletes, so revival stays on the table. A terminal one cannot: the substrate is gone, and only the harvest and the memory survive. Name which at the moment of death — pretending a terminal death is dormant is its own failure of grief.
• Stack-agnostic. Repo, doc, or initiative; with or without a memory store — the ritual is the same.