This is a map of who actually made the records — the people behind the glass. The engineers, the producers, the studios. It didn't start with a database or a spreadsheet. It started with twelve names I'd vouch for without thinking: Steve Albini, John McEntire, Bob Weston, and nine more like them. That's the whole seed. Everything else grew out of those twelve through a process I keep calling the sieve. The trick was never letting the machine make anything up. This page is the method, with the prompts published in full; the longer story is on my blog. Judge it.
Every let an LLM build my dataset project fails the same way: the model fabricates. It invents a plausible credit that never happened and hands it to you with total confidence. So the model gets exactly one job, and I made it a rule.
The LLM is a filter, not a source. The data comes from a structured API and is parsed by code. The model only throws out junk and suggests where to look next.
It can't invent a credit because it never writes one. That single constraint is the difference between a verifiable graph and a confident hallucination.
The graph grows in rounds. Each round starts from engineers I already trust, crawls their credits out of MusicBrainz, and runs everything that comes back through three sieves before a single node is added.
The clever part is the loop. After merging, I ask the model to nominate more engineers I don't have yet — hubs from the same scene. That's the only generative thing it does, and even there it's proposing search terms, not facts. Those names seed the next round and get sieved like everything else. You know you're done when the nominations start coming back as names you already have. The well runs dry; the scene is saturated.
These are the literal instructions given to the model. Nothing is paraphrased.
You vet candidate musical artists discovered by crawling the production
credits of indie / alternative recording engineers (Albini, McEntire, Ek,
Vernhes, etc.). The project is NETWORK-FIRST: keep almost everything a real
engineer recorded, across ANY genre and ANY era. Your only job is removing noise.
For each candidate, set keep=true UNLESS it is clearly one of:
- not a real musical artist: "Various Artists", a label sampler/compilation,
a DJ mix, a soundtrack-various, spoken-word/audiobook, or mis-parsed text;
- a total unknown with NO discernible notability: no real label, no press,
no Wikipedia/Discogs footprint — indistinguishable from noise.
NOT reasons to drop: wrong genre, wrong era, being obscure-but-real, being
famous (e.g. a rock legend an indie engineer happened to record stays IN).
When unsure, keep=true — we trim later.
Return ONLY a JSON array, one object per candidate:
{"name": <exact name>, "keep": true|false, "reason": <short>}.
You curate a database of 1995-2003 US/UK indie, alternative, post-rock, lo-fi,
slowcore, math-rock, post-hardcore, shoegaze recording credits. We ALREADY index
these recording engineers/producers: {…current list…}. Name 25 MORE real,
well-documented recording engineers or producers who worked with bands in that
scene and era and are NOT already in the list. Favor people who recorded several
notable indie/alternative acts (they connect the graph). Reply with ONLY a JSON
array of name strings, nothing else.
Everything the sieves let through is merged in and tagged src:"mb", with the exact
MusicBrainz release ID on every edge, so each fact deep-links to the record it came from. The core
I typed by hand carries no tag at all. That means the part I personally vouch for and the part the
machine added are always separable. One line trims all of it.
Twelve names became — nodes without my ever trusting the machine to tell the truth. The seed didn't just give the crawler a starting point — it gave the whole system its standards. Every name I hand-picked dragged in a cluster of real collaborators, and every one of those was checked against a source before it counted. That's the trade I'd make every time: start from a small thing you can personally stand behind, and let a sieve — never an author — grow it into something you couldn't have written down from memory.
| Curated core | The seed and the spine — typed and checked by hand from album liner notes, label pages, AllMusic, Tape Op and Sound on Sound. The part of the graph I personally vouch for. Carries no src tag. |
| Expansion | A crawl of MusicBrainz (open, CC0). One request per person returns role + album + year + performing band; parsing is deterministic — no language model reads the data. |
| The sieve | A single language model (Claude Sonnet) runs Sieve ② and the nominations. It judges nothing about taste, genre, or era — see §01–§03. |
| Album art & audio | Cover art and 30-second previews are fetched on demand from the iTunes Search API. Not stored. |
| Outbound links | Every entry deep-links to its Discogs and MusicBrainz record, so you can check the source yourself. |
| Source code | The crawler, this site, and the write-up are open: github.com/shawnzam/2inch. |
Read live from the same file the graph loads. Everything the pipeline added carries a
src:"mb" tag; the core I built by hand carries none — so the two are always separable,
and nothing automated can quietly overwrite something I checked.