# Permission to Ignore

---

This morning my portfolio auditor asked me to look at exactly two repositories.

There are 174 in the estate. The other 172 got verdicts too, and nearly all of those
verdicts amount to the same quiet sentence: not this one, not today. Thirty-three are
archived and say so. Seven are parked. Nineteen are experiments that get judged by
experiment rules. Thirty-seven are explicitly excused from risk accounting altogether,
in a tier literally named *deferred*. When people ask what the auditor does, I say it
computes health verdicts, which is true and sounds impressive. What it mostly computes
is permission to ignore.

That took me embarrassingly long to see as the point rather than the byproduct. Every
attention system gets built with the same pitch: surface what matters. Finding what
matters turns out to be the easy half, because almost any scoring function will drag
genuinely broken things toward the top. The hard half is the license going the other
way. A system that can't tell you what to skip hasn't reduced your attention problem;
it has reformatted it.

## The wall of amber

I know how the alternative goes because I've built it, in other domains, more than once.
You instrument everything, you flag everything questionable, and you get a dashboard
where forty items glow some shade of warning. Every item is individually defensible.
Together they train you, within a week, to stop looking. Not because you're lazy, but
because the flags don't rank, and unranked warnings are noise wearing urgency as a
costume. The monitoring world calls the end state alert fatigue. I'd put it more
plainly: a system that cries about everything is teaching you to trust nothing,
including the one cry that matters.

The portfolio version of this failure has a specific flavor. Side projects decay by
default; that's what makes them side projects. Instrument 174 of them honestly and
nearly everything will have something wrong with it: a stale README here, a missing
license there, two years of silence somewhere else. All true. If the tool reports all
of it with equal weight, the honest report and the useless report are the same
document.

## The machinery of not looking

So the auditor spends most of its design budget on ignoring well, through three
mechanisms that turned out to matter more than any scoring rule.

The first is the *deferred* tier. A repo that's archived, or on the archive path, is
excused from risk accounting entirely. So is a repo that's gone stale while not on a
maintenance path. Not scored low. Excused, with the reason recorded. The tier exists
because risk math applied to a resting repo produces exactly the wall of amber above:
of my 174 projects, 37 sit in deferred right now, and every one of them would otherwise
be contributing noise-shaped risk factors to every report I read.

The second is the lane vocabulary. A quiet repo lands in *parked*, which is an
attention word, not a judgment word. Parked doesn't mean healthy and doesn't mean
abandoned; it means "not asking for your week." The distinction sounds cosmetic and
isn't, because judgment words demand resolution and attention words don't. A backlog of
judgments nags. A parking lot just sits there, which is the correct behavior for a
parking lot.

The third is the decision queue, and it's the piece I'd defend hardest. The queue of
things genuinely awaiting a human decision is hard-capped, and every item ships with
evidence and a freshness stamp. And each one carries a standing
instruction, embedded in the data itself: *do not refresh context, roadmap, handoff, or
docs unless that work directly resolves this decision.* That clause exists because I
work with agents, and agents, like humans, default to legible busywork when a real
decision is hard. Refreshing documentation feels like progress, produces a satisfying
diff, and resolves nothing. The queue item pre-empts the theater. It doesn't just say
"decide this"; it says "and here is the specific work that doesn't count as deciding."

## Isn't this just institutionalized neglect?

The obvious objection, and I wrote a whole essay about ghost repos that makes it for
me: fondness is how ghosts get fed, and a tier named "you're allowed to ignore this"
sounds like fondness with a schema. If the auditor excuses whatever goes quiet, decay
gets a rubber stamp.

The mechanism that answers this is small and load-bearing: deferral is downstream of
declaration. A stale repo is excused only when it is *not* on a maintenance path. The
moment I declare a repo maintain, silence stops being restful and starts being a risk
factor again; a maintain repo that goes quiet stays in the accounting, because I made a
promise about it and the system holds the receipt. Deferral never applies to anything I
said I'd keep alive. It applies to the things I've explicitly stopped promising, which
is a different category from the things I've merely stopped thinking about. The system
still can't tell dying from done; no scanner can. What it can do is check what I
committed to, and refuse to excuse anything still under commitment.

And deferred is a ledger entry, not a memory hole. The 37 are counted, listed, and
re-derived from scratch on every snapshot; any of them returns to full accounting the
moment its activity or its declaration changes. Ignoring, done right, is a standing
decision that gets re-earned on every run, which is roughly the opposite of forgetting.

There's one more condition, and it's the price of the whole arrangement: you can only
accept "ignore this" from a system you trust to be current. A permission to ignore,
computed from a stale snapshot, is just neglect with a confidence interval. That's why
the pipeline has to prove its own freshness and provenance before any of its silence
means anything, and that argument got its own essay.

## The scarce resource

None of this is really about repositories. Attention is the only input to a solo
operation that doesn't scale, and anything that consumes it without a decision attached
is a leak. The instinct when you build an audit system is to make it thorough, and
thoroughness is cheap now; the models will happily flag everything, summarize
everything, recommend everything. Which means the differentiating design work has moved
to the other side of the ledger. The question that shapes my tools isn't "what can this
system notice?" It's "what can this system take off my desk, with receipts, so that
when it does speak I actually listen?"

Two repos this morning. I looked at both.