How a Drop Score Gets Made

First it has to know what it's grading. It asks two LEGO databases for the basic facts and merges them: Brickset (price, piece count, minifigure count, theme, year) and Rebrickable (the exact contents). If the two disagree on, say, piece count, Rebrickable's full inventory wins; for the price, Brickset's MSRP is used.

Not every category applies to every set. A flower bouquet has no minifigures; a bucket of bricks isn't trying to be a display model. So before scoring, the engine classifies the set and switches off the categories that don't apply (they're marked "not applicable" and quietly dropped — no penalty).

The types it detects: figureless (no minifigs → Minifigures off), pure display (Botanicals/Architecture/Art → Playability off), parts-pack (a bulk tub → Finished Model off, and the "padding" penalty is suppressed because identical parts are the point), and figure-anchored polybag (a tiny bag sold for one rare minifig → Smart Price off).

The engine pulls the set's complete parts list from Rebrickable — every element, its colour, and how many. From that one list it derives two different things:

• A content summary — how many parts are printed/decorated (vs plain), how much variety there is, and whether the count is padded with hundreds of identical filler pieces. (Used in step 5.)
• A priceable list — each part paired with its BrickLink id and colour id, ready to look up a market price. (Used in step 4.) Conveniently, Rebrickable already carries the BrickLink ids inside each part, so no translation table is needed.

This is the heart of replacing "price per piece." Instead of counting pieces, the engine adds up what the parts are actually worth on the open market.

For each distinct part+colour it looks up the BrickLink price guide — but it only fetches a price it doesn't already have, because a part's value is the same in every set. Prices are saved in a shared cache, so the second set that uses a 2×4 black brick reuses the first set's lookup. It multiplies each price by the quantity, sums it, and gets a part-out value — what the box's contents are worth in parts.

Then the clever part: it computes a value ratio = part-out value ÷ what you pay (the MSRP), and ranks that ratio against a cohort — other sets of the same theme and size class. Sitting at the cohort's median scores ~6/10; a clear bargain heads toward 9+, a clear rip-off toward 3. A set is only scored if enough of its parts could be priced (≥80% coverage) and a real cohort of comparable sets exists.

The other half of "Money & Worth": content density. Are the non-figure parts printed/decorated (which builders prize) or plain? Is there genuine variety, or is the piece count puffed up with identical 1×1s and oversized baseplates? Printed parts push the score up; filler padding pushes it down (unless it's a parts-pack, where identical parts are the whole point).

Now the opinion half. The engine doesn't search the web on demand — that's slow and expensive. Instead a background sweep has already checked a hand-picked list of 48 trusted LEGO reviewers' channels, worked out which set each video is about, and filed them in a "review index." Grading just reads that index.

Matching a video to the right set is the genuinely hard part, because different sets share names (there are six "Razor Crest" sets, three sets named exactly "X-Wing Starfighter", and 32 "Millennium Falcon" sets). So the matcher is careful: it reads the title (not the noisy description) for the set number (rock-solid) or the full name; it ignores a title that carries a different set's number; it won't match a set that didn't exist yet when the video was posted; and each match is tagged high / medium / low confidence. It also pulls in a review aggregator's (Brick Insights) pre-matched links as a second source.

For each review the engine pulls the transcript (for a video) or the article text (for a blog/forum) plus the top comments, and hands it to an AI judge (Claude). The judge does two jobs:

1. Confirms it's the right set. A "ranking every UCS set" round-up, or a review of a different Razor Crest, still mentions the words — so the judge first decides "does this video actually review this set?" If not, it's thrown out. If it's a multi-set video that genuinely covers our set, the judge scores only our set's portion.
2. Scores the experience. For each thing reviewers actually talked about — build fun, instructions, sturdiness, looks, accuracy, playability, parts value, worth-the-money — it gives a 0–10, with a quote for evidence, and it is sarcasm-aware ("oh great, another grey spaceship" is not praise). Anything not discussed is left blank, not guessed.

Reading a review with the AI costs money, so the engine saves the resulting scores (never the review text — just the numbers and a link back). Re-grading the same set later reuses them and skips the AI entirely, unless you force a fresh pass.

Each rubric point (e.g. "build fun") may now have several opinions plus, sometimes, a hard fact. The engine blends them into one 0–10. Every opinion is weighted by three common-sense factors:

• How much it's based on — more reviews count more, but with diminishing returns (going 1→10 matters; 1,000→1,010 barely registers).
• How trustworthy the source is — a structured Brickset rating outweighs a random comment.
• How recent it is — but only for money opinions, which go stale when the price changes; "the build is fun" never expires.

Where a fact defines a point (Smart Price, Build Length, minifig count), the fact is authoritative and opinions only nudge within bounds. One special case: the "feels worth it" crowd sentiment is applied as a small capped nudge to Smart Price — it can fine-tune the hard math but never overrule it.

The points roll up into six categories (each its own 0–10), using fixed sub-weights — e.g. Money & Worth is 65% Smart Price + 35% What You Get. Any point with no data is dropped and the surviving points re-share the weight, so a missing point never silently scores zero.

The six categories combine into one 0–10 by their weights. Same fairness rule: a category with no data (or too little) drops out and the rest re-share its weight, within tier first (a missing big category's weight goes to the other big categories before the medium ones). One guardrail: if, after all that, a single category would carry more than 40% of the whole grade, the grade is flagged as a "data-light estimate" rather than letting a confident letter rest on too thin a base.

The 0–10 is rounded to one decimal (half-up) and mapped to a letter: 9.5+ = A+, 9.0 = A, … 6.0 = C, … below 4.0 = F. The bottom is deliberately coarse — below-average is below-average; we don't over-resolve failing sets.

Every grade ships with two separate honesty signals — they measure different things:

• Coverage (breadth) — how many of the applicable points we could actually score, vs left blank for lack of data.
• Consensus (depth) — how solid the evidence behind the scored points is: lots of agreeing reviews = high; a split room or one lonely data point = low.

The two are independent: a set can have full coverage but low consensus (everything scored, but from noisy, disagreeing reviews), or high consensus on thin coverage. We surface both, and translate them into a plain badge — Locked in · Solid read · Split verdict · Early read · Too quiet — instead of a confusing raw percentage.

Finally it stores the result in the database: the set's facts, the computed grade and per-category breakdown, the part prices it looked up (for the next set to reuse), and the distilled review scores (for the next re-grade to reuse). Only derived data and links — never anyone's review text.