liquidation, not loss

the numbers first, because they're the only real numbers in this whole series: 4,863 videos. about 25 minutes. $0. 100% preserved.

i wrote up the mechanics last november. this post is about why backlog liquidation is the first protocol in an anti-rot series and not a housekeeping tip — and how to run it yourself, with or without maios.

a backlog is passive consumption with receipts

a watch later list is supposed to be a to-do list. mine had become a monument. 4,863 videos is roughly 800 hours. i was never going to watch 800 hours, and neither are you.

but look at what the queue actually is. every entry is a moment where i was curious about something, and instead of learning it, i saved it. saving is the cheapest way to feel like you've learned something. one click, a small hit of "handled," and nothing in your head changes. the queue is a decade of those clicks. it's cognitive offloading with a nicer name — bookmarking as a substitute for thinking.

it's not free, either. i paid a small daily tax of guilt for years. 4,863 things i owed a version of myself who was never going to show up.

the reframe that got me out is the title. liquidation, not loss. you don't clear the backlog. you convert it. the curiosity that built the queue was real — that's the proof-of-work — and the videos are just the wrapper.

the protocol

five stages. extract → structure → liquidate → process → integrate.

extract (~3 minutes): a script pulled all 4,863 entries with metadata — title, url, length, percent watched. this is the only step where you touch the platform, so get everything in one pass.

structure (~2 minutes): convert to a machine-readable table, dedupe, merge into the vault. now the backlog is a file i own instead of a list someone else hosts.

liquidate (~20 minutes): a script in the browser console zeroed the playlist while i watched the counter fall. this is the satisfying part, and it's also the dangerous part, which is why it's the only step with a rule attached. see below.

process (runs on): a worker walks the urls, fetches transcripts, and emits one tagged note per video — summary, key points, tags. this is the step the model does, and it's the right step for it. a machine reads a transcript in seconds; i used to pay an evening.

integrate (human): link the notes into the graph by topic cluster — not by the order i once panic-saved them in. this is the step the model doesn't do, and that's the whole point. i'll come back to it.

the one rule

extract → verify → delete. never delete before capture is confirmed.

the delete is the only irreversible step in the pipeline, so it goes last, and it goes after a check. i opened the export three times before running the delete script. counted the rows. spot-checked a dozen urls. paranoia is cheap; a decade of curation is not.

if you take nothing else from this post, take the ordering. people skip verify because the counter falling is fun. then they discover the export was paginated at 500 and they own 4,363 videos of nothing.

why this is a thinking practice and not tidying

here's where it stops being a productivity post.

after processing, i had 4,863 notes, each with a summary a model wrote. if i'd stopped there, i would have converted a backlog of videos into a backlog of summaries. smaller, searchable, and exactly as unread. an ai-written summary you never engage with is just a more compact way of not learning something.

what makes it liquidation instead of loss is integrate. that's me, reading a cluster of twelve notes on the same topic, deciding which three actually matter, linking them to the thing i'm building this month, and archiving the rest. the model reduced the cost of the raw material from an hour to a minute. the minute is still mine, and the minute is where the learning is.

so the protocol has a shape you'll see across this whole series: the machine does the extraction, the human does the deciding. the ai proposes a note; i decide whether it becomes part of what i know. that split isn't a limitation of the tooling. it's the design.

what it looks like in maios

the protocol is shipped as backlog liquidation. paste a pile of youtube links or read-later urls; the watcher processes each one into a single tagged note under /Liquidated. process one, or hit "process all" and it works through them one at a time; if it stops, run it again and it picks up the ones still queued. with the pwa installed, "share to maios" shows up in your phone's share sheet, so a link goes straight into the queue instead of into a bookmark you'll never open.

there's a books preset too: export your goodreads library as csv, paste it, and each book becomes a brief note. no url to scrape, just the shelf you've felt guilty about since 2019.

the integrate step is deliberately not automated. the notes land; the linking is yours.

how to run it without maios

you don't need the app. you need the ordering.

1. export the whole queue with metadata. whatever tool you're leaving, find the export, not the "clear all."
2. put it in a file you own. a csv is fine.
3. verify. count rows. open a few.
4. delete the source. watch the counter fall. enjoy it.
5. run something over the urls that produces one note per item. a script, a batch of prompts, a patient friend.
6. read the clusters yourself and link the ones that matter to something you're doing now.

it generalizes to anything you've been hoarding. tabs. podcasts. read-later apps. the 1,400 pdfs in a folder called to_read. the shape is the same: extract, verify, delete, then think.

changed owners

the backlog didn't disappear. it changed owners — from a platform's servers to my vault, from guilt to raw material. the algorithm no longer decides when i get to learn something i chose to be curious about.

your backlog is a well, not a debt. stop apologizing for it and start drawing from it. just check the export three times first.