Kill With Dignity

This month I found out that roughly sixty of my repositories were lying to me in the same direction at once. Each one declared itself active, on a weekly review cadence, in the registry my own tools maintain. And under each claim sat the same evidence: months of dependabot merges, license normalizations, CI housekeeping. Machine churn, not a human hand anywhere. No single repo was the liar. The portfolio as a whole had learned to look busy, the way an office learns to look busy when the manager walks the floor.

The uncomfortable part is that I already had the instrument that could see this. I have written before about treating a portfolio as an observability problem: GithubRepoAuditor (github.com/saagpatel/GithubRepoAuditor) walks all of my repositories and produces an evidence file about each one, when commits actually landed, whether tests exist, whether the machinery of maintenance shows real motion. The facts were all there. I had been reading them for months.

And I had changed almost nothing. That is the gap this essay is about. Observability tells you what is true. It is structurally incapable of telling you what to do, because "this project is dead, bury it" is not a fact. It is a judgment, and judgment turns out to be a separate instrument that has to be built separately, with its own discipline, its own failure modes, and its own way of earning trust.

So I built a tribunal and put all 182 projects on trial.

The instrument

The design is small enough to describe completely.

Every repository gets an evidence bundle: the auditor's structured truth about it, the opening stretch of its README, and its last few commits. Absence counts as evidence. A repo with no README is telling you something no README could, and a repo with no reachable git history does not get quietly skipped; it gets flagged for investigation, because a judgment layer that guesses over missing evidence is worse than no judgment layer at all.

A judge, a large model working under a written rubric, reads each bundle and rules KEEP, PARK, or KILL. There is a fourth verdict, INVESTIGATE, which exists so that refusing to decide is a legal ruling rather than a failure state. The rubric walks a fixed set of axes: declared purpose, evidence of real consumption, forward intent that exists in bytes rather than in my fond intentions, cost to revive. The axes end in a default, and the default is zombie. A project with no purpose, no consumers, and no written path forward does not get the benefit of the doubt. The doubt is the verdict.

The part I trust most is the least glamorous: a schema validator sits between the judge and the ledger, and a verdict does not parse unless it cites at least two pieces of evidence drawn from at least two different sources in the bundle. The judge cannot vibe. It can be wrong, but it has to be wrong on the record, in a form I can check, which is the property that makes being wrong survivable.

If you have read the rest of this series, you will recognize the posture. A machine's account of itself is a claim, not a fact, and every claim gets checked against something that cannot be minted on the project's best day. The tribunal just aims that posture at a new target: not the agent's report, not the guard's finding, but my own accumulated pile of past selves, each one insisting its project still matters.

The judge earns it

I did not let the tribunal rule on 182 repositories cold. It ran a calibration docket first: twenty projects judged in full, with me reviewing every verdict before the instrument got the rest of the portfolio.

I accepted nineteen. The twentieth was a project called Conductor, and the judge said KILL, reasoning that a newer project of mine covered the same ground, so the older one was superseded. I overrode it to PARK, and the override is the most important thing that happened all weekend, because of what it forced. The rubric was amended, in writing, before the full run: overlap is not absorption. A newer project touching the same domain does not absorb an older one unless it demonstrably replaced the older one's use. And a missing toolchain, the judge's other exhibit, prices the cost of revival; it never justifies a death sentence on its own.

I have written about how a grader earns the right to grade, and this is the same law seen from the bench. The judge did not earn my trust by being right nineteen times. It earned it by being corrected once, on the record, in a way that permanently changed how it judges. A judgment instrument you have never overridden is an instrument you have never actually calibrated. You do not know whether it defers to you or agrees with you, and those are different machines.

Three kinds of death

The full run came back: 70 KEEP, 73 PARK, 39 KILL. Every INVESTIGATE, fifteen of them, was resolved by doing the read it named before anything went in the ledger. Zero guesses survived to the final record.

The 39 kills are the reason this essay has its title, because once you read them as a group, they sort into three kinds of death, and only one of them is sad.

The first kind is the answered experiment. One repo existed to ask a single question: does steering a model's internal features feel like playing an instrument? It was built in a day, it answered yes, and the answer was recorded. That repository is not a corpse. It is a completed life. It asked, it answered, it ended. The kill verdict cites the project's own success as the grounds for its death, and filing it as KILL is not a loss; it is the correct way to honor a finished thing. Keeping it on life support in an "active" registry would be the disrespectful move, the taxidermy option.

The second kind is the closed campaign: repositories whose own closeout documents said, in plain language, finished, done, all deliverables verified. Some had been saying it for weeks. Nobody had believed them, because in a portfolio where everything claims to be alive, even a project announcing its own completion reads as just another status light. The tribunal's contribution was simply to take the repos at their word.

The third kind is the only sad one, and its sadness is the honest kind. The zombie scaffold: a project created from a template that never received a single product commit. Its entire history is license fixes and dependency bumps. It never lived, and the registry had it marked active, because nothing in an observability layer distinguishes a heartbeat from a metronome.

This is what I mean by killing with dignity. A kill verdict grounded in evidence, citing the project's own record, distinguishing a completed life from an abandoned one, is not portfolio hygiene. It is the thing that makes every KEEP mean something. A portfolio that cannot kill has no live projects; it has 182 unmarked graves and no way to tell which ones are occupied.

The rescues

Here is the part that convinced me the tribunal was judging rather than rubber-stamping: it ruled against its own registry.

Three pieces of infrastructure had been archived by an earlier, mechanical cleanup pass. The tribunal read their bundles and escalated all three back to KEEP, because the evidence said they were alive; one of them was quietly indexing my notes every single day while its registry entry called it retired. And one iOS app had been archived over an incident, a corrupt checkout during a bad week, rather than over any judgment about its life. Substantive work had landed on it since. The tribunal ruled it frozen, not buried, on the grounds that an incident is a fact about a Tuesday, not a fact about a project.

A judge that only ever agrees with the existing record is not a judge; it is a notary with opinions. The disagreement rate with the status quo, in both directions, killing what the registry called active and reviving what the registry called dead, is the signal that the instrument is reading evidence rather than reading the labels.

What happened next, and what the tribunal is not

The verdicts were not the product. The next morning, the registry got 96 lifecycle changes applied in one reviewed pass. The review cadences that had been quietly lying, weekly reviews declared on dormant projects, were made coherent with the verdicts. The dead repositories started getting archived on GitHub, visibly, where anyone can see the label. The portfolio now tells a stranger, and more importantly tells me, roughly the truth about itself.

I should be honest about the instrument's limits, because the series demands it. The judge is a model, and a model under a rubric is still a model: the schema validator forces its verdicts to be grounded, but grounded and correct are not synonyms, which is exactly why every disposition passed through an operator review before it touched the registry. The verdicts are point-in-time; a PARK can wake up, a KEEP can rot, and the tribunal will have to sit again. And the whole apparatus shares one author, which means it inherits my blind spots even as it corrects my fondness. The bench is independent of my sentiment, not of me.

But the chassis turned out to be the real product. A written rubric, schema-enforced citations, a calibration docket, an operator gate: that skeleton took a weekend to build and then generalized twice in the same weekend. The second instrument built on it judges delegated agent work after the fact, comparing what I asked for against what the diff actually contains, on the doctrine that divergence is normal and the crime is silence. The third judges my decisions before I execute them, by holding each one up against my own documented history of regrets. Judgment stopped being an event I occasionally perform in a burst of guilt and became a layer of the system, with the same standing as observability.

The sixty repositories that were all lying in the same direction are not lying anymore. Not because they changed. Because something other than me was finally allowed to say so out loud, and it had to show its citations to speak.