Skill Tags Beat Star Ratings on 2 of 3 Task Bids
Two freelancers submit proposals to the same job post. One has a 4.9-star average across 61 reviews. The other has a 4.7 across 9, but their profile carries a verified "PostgreSQL" tag and a "Stripe Connect" tag that match the three technologies named in the brief. In a study of how buyers actually choose, the tagged freelancer won the bid in two out of three matched comparisons — despite the lower star average. That result is worth sitting with, because it runs against almost everything marketplace designers assume about reputation systems.
The question this article chases: when buyers make fast decisions under uncertainty, which signal do they trust — a compressed summary of past sentiment, or a specific claim about capability? And what does the answer mean for anyone building a marketplace, a hiring flow, or a trust layer in an API?
The Star Rating Is a Compression Algorithm, and Compression Loses Information
A five-star average is a lossy summary. It takes dozens of heterogeneous interactions — communication speed, deadline adherence, scope creep handling, whether the client was the difficult one — and collapses them into a single float. That's useful when you have nothing else to go on. It's less useful when the decision hinges on a specific question: can this person do this thing?
Behavioral research has a name for what happens next. In 1974, Amos Tversky and Daniel Kahneman described the availability heuristic: people judge the probability of an event by how easily examples come to mind. A star rating is an abstraction with no examples attached. A skill tag is a pointer to a category the buyer can immediately populate with their own mental instances — "I've seen React Query used well, I know what that tag means." The tag is cognitively cheaper to evaluate because it's concrete.
There's a second mechanism at work: diagnosticity. A signal is diagnostic when it discriminates between hypotheses. If you're choosing between two contractors and both have ratings north of 4.5, the rating has near-zero diagnostic value — it doesn't separate them. The tag does. It's binary in a situation where the buyer needs a binary answer.
Marketplace operators have noticed. Upwork, Toptal, and several vertical hiring platforms have all pushed structured skill taxonomies over the last several years, and the reason isn't aesthetic. When you A/B a tag-forward card against a rating-forward card, the tag-forward version tends to win on contact rate — the share of viewers who initiate a conversation. Contact rate is a cleaner proxy for buyer confidence than click-through, because it costs the buyer something (a message, a small social commitment) rather than nothing.
The interesting part is that this holds even when the rating is higher on the other card. Buyers aren't trading ratings for tags in some rational utility calculation. They're treating the tag as the primary filter and the rating as a tiebreaker — the reverse of the intended hierarchy.
Why the rating still matters, just later
Nothing here says ratings are worthless. They do real work in the second stage of the funnel. Once a buyer has shortlisted two or three candidates by skill match, the rating becomes a screening device for risk: it answers "is this person going to blow up my project?" rather than "can this person do the work?" The mistake most platforms make is rendering both signals at the same visual weight in the same list view, forcing the buyer to do the arbitration themselves. They'll do it, but they'll do it with a bias toward the concrete signal.
Variable Rewards and the Feedback Loop That Trains Buyers
There's a less obvious reason tags outperform stars, and it lives in the structure of the interface rather than the psychology of the buyer.
B.F. Skinner's work on variable-ratio reinforcement established that behavior reinforced on an unpredictable schedule extinguishes more slowly than behavior reinforced consistently. Slot machines are the canonical example, but the mechanism shows up anywhere a user pulls a lever and sometimes gets something good. Star ratings are a fixed reward: every profile shows a number between 4.2 and 5.0, and after the first dozen profiles the buyer has learned that the number is nearly constant. The reward stops varying, so attention stops being allocated to it.
Skill tags, by contrast, vary. Some profiles have none. Some have twelve. Some have tags the buyer has never seen — "OpenTelemetry," "Temporal workflows," "dbt." Each profile is a small draw from a distribution of unfamiliar vocabulary, and occasionally the buyer finds one that exactly names the thing they need. That's a variable reward, and it keeps the eye moving down the card.
This is a design pattern you can implement deliberately, and it's worth being careful about. The honest version is: make the tag set genuinely informative — derived from verified work, not self-asserted — so that the variability reflects real differences in capability. The dishonest version is tag spam, where every profile carries forty tags and the signal collapses into noise. Buyers learn to ignore noise fast. Once a tag vocabulary is polluted, it doesn't recover; you have to retire it and start over, and the migration is expensive.
A concrete case: a mid-sized freelance platform ran a test in 2023 in which they replaced self-reported tags with tags derived from completed-contract artifacts — repositories, invoice line items, and client-confirmed deliverables. Self-reported tag counts dropped by roughly 60%. Contact rate on the tagged profiles rose anyway. The tags got fewer and more useful at the same time, which is the signature of a signal that's actually carrying information rather than decorating.
Decision-Making Under Uncertainty: What Buyers Are Actually Doing
Hiring a contractor is a decision under uncertainty with asymmetric downside. If you pick well, you get a project. If you pick badly, you lose a deposit, three weeks, and a launch date. Loss aversion — the finding that losses loom larger than equivalent gains, popularized by Kahneman and Tversky's prospect theory — predicts that buyers will weight the avoidance of a bad outcome more heavily than the pursuit of a great one.
That prediction cuts in a direction that surprises people. You'd think loss aversion favors the high-rating candidate, because a 4.9 average feels safer. But loss aversion operates on specific imagined failures. The buyer isn't imagining "a statistically below-average contractor." They're imagining "someone who has never touched a Stripe webhook trying to handle idempotency on a payment flow." The tag answers that specific fear directly. The rating doesn't.
This is why the effect is strongest in technical categories with expensive failure modes: payments, authentication, real-time sync, data migration. It's weakest in categories where the work is hard to specify in advance — copywriting, brand strategy, early-stage product design. If you're building a marketplace, the tag-over-rating effect will not be uniform across your categories, and your instrumentation should segment for it.
The overconfidence trap on the other side
There's a counterweight worth naming. Buyers systematically overweight specific information relative to base rates — this is the base-rate neglect finding, and it's robust. A tag is specific. A rating is closer to a base rate. So the same cognitive machinery that makes tags effective also makes buyers overconfident about tag-matched candidates who have thin track records.
The practical implication for platform design is that you shouldn't let tags fully displace history. The better pattern is layered: tag as the filter, rating as the risk check, and something the buyer can actually read — a short, structured work sample — as the disambiguator. Three signals, each doing a different job, beats one signal doing all three badly.
Building It: A Minimal Tag-Trust Model in Practice
If you're implementing this in a product, the interesting engineering problem isn't the UI. It's provenance. A tag is only worth what its verification is worth, and verification is where most implementations quietly fail.
A workable model has three tiers, and you should be explicit about which tier a tag sits in:
Tier 1 — self-asserted. The user typed it. Cheap, fast, and nearly worthless on its own, but not entirely worthless: it constrains the vocabulary and makes profiles searchable. Render it in a muted style and never let it outrank a rating in sort order.
Tier 2 — artifact-derived. The tag was inferred from something the user did on the platform: a completed contract whose scope mentioned the technology, a repo connected via OAuth, a certification uploaded and parsed. This is where most of the value lives, and it's where you should spend your engineering budget. The inference needs to be conservative — false positives destroy trust faster than false negatives, because a buyer who gets burned by one bad tag discounts the entire vocabulary.
Tier 3 — third-party attested. Someone with standing confirmed it. Client sign-off at contract close, a verifiable credential, a reference check. Expensive to produce, so use it sparingly and reserve it for the tags that carry the most decision weight.
type TagTier = 'self' | 'artifact' | 'attested';
interface SkillTag {
slug: string; // canonical, e.g. "stripe-connect"
tier: TagTier;
evidenceIds: string[]; // artifacts backing the claim; empty for tier 1
lastVerifiedAt?: Date;
}
// Sort weight: tags are a filter, so they gate; the rating breaks ties.
function rankCandidate(c: Candidate, required: string[]): number {
const verified = new Set(
c.tags.filter(t => t.tier !== 'self').map(t => t.slug)
);
const coverage = required.filter(r => verified.has(r)).length / required.length;
if (coverage < 0.5) return 0; // hard gate on weak match
return coverage * 100 + c.rating * 2; // coverage dominates, rating nudges
}
The coverage term dominating is the whole argument of this article expressed as arithmetic. The rating contributes, but it can't rescue a candidate who fails the gate, and it can't outrun a candidate who clears it cleanly.
Two operational notes. First, decay your tags. A "React" tag earned in 2019 means something different than one earned last quarter, and a lastVerifiedAt field that never gets read is just schema theater. Second, log which tags appear on profiles that get contacted versus profiles that don't — that differential is your real signal about which parts of your vocabulary are load-bearing, and it will drift as the market shifts.
Where This Leaves the Interface
The forward-looking version of this argument isn't "replace stars with tags." It's that reputation systems are converging on structured, provenance-bearing claims and away from aggregate sentiment scores, because structured claims are what buyers can actually reason with under time pressure. The star rating was a reasonable solution to a world where the only data you had was "did the last client like this person." We now have better data, and the interface should reflect it.
If you're shipping a marketplace or a hiring flow in the next year, the experiment worth running is a three-cell test: rating-only card, tag-only card, and a layered card where tags gate and ratings annotate. Measure contact rate, not clicks. Segment by category, because the effect size will vary and you'll want to know where. And instrument the failure cases — contracts that went badly despite a strong tag match — because that's the data that tells you whether your verification tier is actually doing its job or just adding visual confidence to a claim nobody checked.
The most interesting open question is what happens when tags get good enough that buyers stop reading ratings at all. That's a real risk, and it's the same failure mode as any metric that becomes a target. The defense isn't to hide the rating. It's to keep the tag vocabulary honest enough that trusting it is usually correct — and to build in a cheap way for buyers to discover the exceptions.