What a Robot Learned Scraping Speedruns at 3 A.M.

An autonomous research loop ran overnight against SrTDb's library. The trick database grew — but the more durable output was a stack of lessons about how this kind of work actually behaves when you do it at scale, in the dark, against systems that push back. Here are the ones that changed how the pipeline runs.

YouTube's rate limit is a window, not a rhythm

The obvious mental model is wrong. You imagine that if you space requests politely — a jittered sleep between each caption fetch — you stay under the limit. You don't. The 429 is cumulative per-IP load inside a time window, and it does not care how gentle your spacing is.

Worse, the flag is sticky and easy to re-trip. Over one night this home IP got 429'd, waited, tried a different tiny game three and a half hours later — and it 429'd again, on the second video. A caption-only re-fetch with the search results already cached — the lightest possible operation — tripped one too. The honest nuance the logs forced on us: each sweep's backoff rode through those transient per-video 429s and still finished its batch. The rate limit isn't a wall that drops at a fixed count; it's a tax that gets levied unpredictably under load, and you pay it whether or not you've been polite.

Treat the rate limit like weather, not a queue. You don't out-schedule weather. You wait for it, take what you can while it's clear, and do everything else indoors.

The operational rule that fell out of this is subtler than "back off." A single capped, paced sweep — one game, fifteen captions — reliably lands its batch even while shrugging off a couple of mid-sweep 429s. What actually caused the original meltdown wasn't one sweep; it was stacking several fresh-game searches into a tight window. So the rule is: one game at a time, spaced out, with a modest per-sweep cap, let the backoff absorb the transient refusals, and spend the rest of your time on local work that has no limit.

A world-record run is footage, not a source

Here's a result that felt backwards at first. We harvested a clean set of world-record runs for a game — exactly the videos you'd think are most authoritative — fed their captions to the extractor, and got zero tricks. Not noise. Zero.

The reason is obvious in hindsight: a WR submission is usually a silent solo run. No commentary, no explanation, just inputs. The auto-captions transcribe nothing useful because nobody is saying anything. A world record is the best possible footage of a trick and the worst possible description of one.

The extractable corpus is the opposite of prestige: marathon couch-commentary (GDQ, ESA — two runners narrating each other's mistakes) and tutorials. Those are where someone says out loud, "okay, you wall-jump here, frame-perfect, or you fall short." That sentence is the find. The flawless silent run is just the proof.

Obscure does not mean low-information

We assumed the niche games would be barren. The opposite happened. A tiny, obscure handheld game — the kind with a leaderboard you could fit in a phone booth — yielded 604 trick drafts from a handful of marathon captions, including a damage-boost tech the runner had named himself. Meanwhile a far more popular title gave up nothing, because the only captions we'd pulled were those silent WR runs.

Information density is a property of who's talking, not how famous the game is. An obscure game with one chatty expert at a marathon beats a household name with ten wordless records. When you're deciding where to dig, follow the commentary, not the popularity.

"Two independent sources" means two people

The database rule is that a trick isn't verified until two independent sources agree on it. The mechanical gate enforces this by counting distinct video IDs. That gate is wrong in a specific, dangerous way.

A runner named coolkid has a Mega Man 2 run from SGDQ 2019 and another from AGDQ 2022. Two different videos, two different years, two distinct IDs — the gate is satisfied. But it's one person demonstrating the same thing twice. That's not independent corroboration; it's one source with two timestamps. The trick is true, but it's under-sourced by our own rule, and promoting it would have quietly lowered the bar for everything after it.

Independence is a property of people, not of URLs. The machine can count URLs. Only a human (or a careful prompt) can ask, "wait, is this the same runner?"

So two coolkid runs stayed held. The fix isn't to relax the rule — it's to remember that the cheap automated check is a proxy, and proxies leak.

When the expert is in the room, the math changes

The two-source rule has an escape hatch, and learning to use it unblocked a whole category of work. For the games whose top experts will be physically present at a marathon to verify tricks, the expert is the second source. You don't need two independent videos for a game whose world-record holder is going to watch the clip and tell you whether it's real.

This reframed a problem we'd overstated. We'd been treating thinly-harvested games as blocked — "can't get two sources, can't verify." But for expert-attended games you only need enough footage to flesh the trick plus the expert's eyes. One good clip, fully described and cited, marked as expert-pending, is a complete deliverable. It turned "we're stuck" into "we're ready for the human."

The commentary is talking about a different game

This is the one that nearly burned us, and it's the subtlest. We had a correct-game video — verified, on-topic, the right run — and the extractor still produced a wrong trick.

The flashiest draft of the night claimed the obscure game had arbitrary code execution — write-anywhere memory corruption, the holy grail of glitches, "saves 45 minutes." Spectacular, if true. It wasn't. Reading the full caption window showed the runners chatting about Paper Mario: The Thousand-Year Door during a loading screen. Another batch of "tricks" was lifted from them reminiscing about Bloodstained. The video was the right game; the conversation wandered, and the model attributed everything said to whatever was on screen.

Couch commentary is two friends talking. They will talk about other games. A transcript doesn't know the difference between "here's the trick" and "did you see what happened in that other run."

The mitigation is now mandatory: before fleshing any marathon-sourced draft, read the full window and confirm the mechanic names this game's own places and objects. "Take damage from the fish wall" is unmistakably our game. "TTYD has crazy stuff now" is not. Raw drafts are not trustworthy on game-identity even when the video is correct — which is exactly why turning a draft into a verified trick is human work, not an automatic promotion.

Don't fix what you haven't reproduced

A background worker that fetches captions appeared broken — it ran for hours and pulled nothing. The tempting move, especially at 3 a.m., is to dive into its code and "fix the gap."

The worker wasn't broken. It pulls nothing when there's nothing to pull, and the pool was exhausted; the one case where it looked like it should have fired was a timing artifact, swallowed by the same rate-limit cooldown everything else hit. Editing a live, working service on a hunch would have been the actual bug. The discipline that saved it was boring and old: reproduce and understand the failure before you change anything. A confident wrong diagnosis is more expensive than an unsolved mystery.

The shape of the work

Underneath the specific lessons is one structure that kept proving itself. The local model is a tireless, noisy drafter — it reads every caption and casts a wide net, and 95-plus percent of what it nets is junk, off-topic chatter, or another game entirely. Its job is breadth. The verifier's job is the opposite: refuse to ship anything without a citation that survives a careful read.

The repeatable recipe that came out of the night: harvest a corpus, classify it, spend your one rate-limited fetch wisely, extract drafts locally, then read each promising draft against its source and flesh only the ones that hold up. Two previously-untouched games went through that pipeline and came out with real, cited, expert-ready tricks.

None of these are profound. They're the kind of thing you only learn by doing the work badly once and noticing. Which is the last lesson, really: an autonomous loop earns its keep not when it produces data, but when it produces corrections — and writes them down where the next run will read them.