I almost shipped an app that would have quoted you $200 for a $7 comic

I almost shipped an app that would have told you your $7 comic was worth two hundred dollars.

I want to walk through what happened, because the fix is the whole philosophy behind Comic Scry — and it’s the opposite of what most “point your phone at it and get an answer” apps do.

The moment it went wrong

I was testing Comic Scry on books from my own collection. Pointed the phone at Magic: The Gathering — Theros #1. The app came back confident: $40–$200.

Felt off. I figured it for a few-dollar book. But the catalog said otherwise, and the source data behind it read authoritative — a tidy summary citing price guides.

So I checked what the book was actually selling for. Recent sales were under ten dollars. Nowhere near $200. The app was off by more than 20x, and completely sure of itself.

Why it was wrong

I pulled the evidence behind that catalog number. Here’s the line that broke it:

“Asks have ranged $50–250+ on rare appearances.”

Asks. Not sales.

The research that seeded the catalog had scraped asking prices — what sellers hope to get — and treated them as market value. It sounded authoritative because it was stated confidently. It wasn’t true. And the bias only ever runs one way: asks overstate value, never understate it. A few rows too low and someone quietly underprices a book. Many rows too high and every person with a $5 comic in a box thinks they’re sitting on a windfall, takes it to a shop, gets told no, and goes home feeling lied to.

That’s the failure mode I don’t want to ship.

Code, AI, Code

Here’s the thing I already knew from years of building with AI, and that this bug drove home again: the AI is not the product. The discipline around it is.

The pattern I build everything on now:

1. Do as much as possible in plain, deterministic code. AI is excellent at writing that code — fast, correct, well-tested. Lean on it there.
2. Apply the model only where deterministic code can’t reach — reading a cover, interpreting messy art. That LLM step is magic powder. You use as little as you can, as narrowly as you can.
3. Then check the result in code again. Cross-reference it. Bound it. Catch the obvious lie before the user ever sees it.

Code, AI, Code. The model interpretation sits in the middle, small and targeted, wrapped on both sides by logic you can actually verify. And you feed it from as many aggregated data sources as you can — because more grounding makes both the prompt side (what the model sees) and the eval side (how you check what it said) sharper.

A scan is not “send an image, believe the answer.” That’s the version that quotes $200 for a $7 book. A scan is identify, ground, verify — and say so when any of those comes up short.

What that looks like in identification

Identity comes first. Before we ever talk price, the app has to know which exact book this is — because two printings that look nearly identical can be worlds apart in value. A $1,500 first printing of Amazing Spider-Man #129 and a $7 facsimile reprint of the same cover are, to a camera, almost the same picture.

So every printing gets its own stable ID, with a slot for the variant:

scid:marvel/amazing-spider-man/129/1974/standard    — original
scid:marvel/amazing-spider-man/129/2024/facsimile    — reprint
scid:idw/mtg-theros/1/2014/standard                  — common
scid:idw/mtg-theros/1/2014/gamestop-rewards          — variant

Right now the focus is nailing core identification — series, issue, year — as reliably as I can. The schema has room for variants, and we catch the obvious ones, but we do not yet distinguish every variant and printing out there, and I’m not going to pretend we do. When the app can’t tell which edition you’re holding — no year on the cover, more than one printing it could be — it stops and asks you instead of guessing. A confident wrong answer is worse than an honest “which of these?”

What that looks like in pricing

I tore out the old pricing layer and rebuilt it on one rule: every number shows its work, or it doesn’t show up.

• Prices come live from the server now — grounded in real transaction data, not aggregated asks. There are no prices baked into the app anymore; if the system can’t back a number, you get a blank instead of a guess.
• The value is derived, versioned, and bounded: a gated low (reprint-contaminated comps dropped, so a clean copy doesn’t float on a reprint’s price) up to a graded-copy ceiling, with a per-grade ladder so a slabbed book is priced at its grade, not a generic range.
• Slow or rate-limited lookups come back pending and quietly backfill — the card upgrades itself in place rather than freezing a stale guess.
• Every quote names its source and the date it was verified. When that date is past our staleness window, the card says so: “Treat it as a starting point — the market may have moved.”

The part that’s still hard

The frontier right now is art covers — the painterly, logo-only, foldout covers that are gorgeous and say almost nothing. No issue number, no price, sometimes barely a title. They’re a joy to look at and, today, nearly impossible to read in a way I’d trust. Pixels-to-identity is the only path that can ever crack them, and I’m working on it. Until I can do it honestly, the app will tell you when it isn’t sure rather than invent something.

That’s the whole posture: identify what we can, ground it in real data, verify it, and be plain about the rest.

Why I’m writing this

I’m not going to tell you what every other app does behind the scenes — I don’t know. What I do know is that this stuff is genuinely hard to get right, and it’s easy to reach for a band-aid, or to hope the bad path won’t fire the second time. It usually does.

I’d rather build the harder version and show the work — including the parts that aren’t finished.

Comic Scry is live: point your phone at any comic cover, get a tier and a price you can actually check. Five free scans, no signup. You can watch it get sharper on the changelog.