Verdict

❝Card processors flag a fraction of transactions for human review. A model scores each one, and a person approves or declines. Verdict is the console that person works in.

It is self-initiated. There is no client, nobody was interviewed, and nothing is deployed to production. I researched the domain from published card-network documentation and risk-operations writing. I have not worked in it, and the case would be worth less if I pretended otherwise.

So it claims no outcomes. What it claims instead is that every number below is a property of the repository, reproducible by anyone who clones it and runs the build.

❝Two people use this. A reviewer works 200 to 400 flagged transactions a shift, measured on both speed and accuracy, which pull against each other. A risk manager sets the threshold that decides how much lands in the queue at all.

Their problems are different in kind. The reviewer is drowning in context switches. The manager is flying blind.

❝Almost every tool in this space renders risk as red, amber and green. That is a categorical encoding of an ordered quantity. It collapses a continuous score into three buckets, it fails colour-blind reviewers, and it dies on the projector in a shared operations room.

Verdict encodes risk as one hue climbing in lightness, plus an explicit rank, plus the printed numeric range. Three redundant carriers, so the ordering reads with no colour perception at all.

This is the decision the rest of the system hangs off. It produced the token architecture, the accessibility argument and the central instrument in one move.

❝Six screens generated in an afternoon, five of them killed by the end of it. That is not waste, it is the method.

Slop is what happens when the generated artifact becomes the deliverable. Here the artifact is disposable by design: it exists to make an argument visible fast enough to reject. Nothing generated survives contact with the system layer, because the system layer is built after the exploration and rebuilt from tokens up.

The order matters more than the tools. Tokens before components, components before screens, screens before flows. Reverse any two of those and the result is a demo that cannot be extended.

❝Speed is only worth having if judgement stays where it belongs. So the boundary is explicit rather than intuitive.

The clearest way to show that boundary is not to describe it. It is to show what the model proposed and what shipped instead.

❝Three tiers. Primitives are raw scales that no component may name. Semantic roles are the only tier a component reads, and the only tier that differs between light and dark. Component tokens alias semantics and never reach past them.

The rule is worth nothing unless something checks it. The build exits non-zero on a tier violation, on a role defined in one theme and missing from the other, and on any contrast pair below its gate. A custom lint rule bans raw hex outside the token source.

The gate caught eleven failures on its first run. One of them was not a bad colour value but a wrong idea: a sequential ramp can never carry 3:1 between adjacent steps, because that is what makes it sequential. The band boundaries moved onto tick marks and printed ranges, which is where the contrast requirement actually belonged.

❝Sixteen components in five categories, and the category is not a filing convenience. It determines what a component is allowed to know.

A primitive takes visual props and nothing else. The moment a Button understands what a decline is, every future consumer inherits fraud vocabulary it did not ask for. Domain components are allowed to be un-reusable, and saying so out loud prevents the usual failure, where everything is flattened into a generic library that fits nothing.

The base is shadcn on Radix rather than a hand-rolled headless layer. Radix supplies the parts that are cheap to get subtly wrong and expensive to find in an audit: indeterminate checkboxes, roving focus, dismissal on Escape.

❝A component that only exists in its default state is a mockup. The states that break a handoff are the ones nobody drew: empty, loading, failed, one item, four hundred items, a customer name too long for the column.

So every component carries a story per applicable state, and the matrix below is the coverage, not an aspiration. Grey cells are combinations that genuinely do not apply, marked rather than quietly skipped, because an unmarked gap and a deliberate exclusion look identical in a screenshot.

❝Working a case is optimised for speed. Moving the threshold is optimised for consequence. They sit in one system and behave nothing alike, and that is the point.

Consistency in a design system means the same components and the same vocabulary. It does not mean the same ceremony regardless of what is at stake. A tool that treated these two moments identically would be wrong twice.

❝The riskiest claim a designer can make is that they ship production code. So this is stated as a scope with an explicit list of things I did not do.

What I hand a team is design-complete, typed, accessible and running, with mock data. What I do not hand them is a data layer, an auth model, error semantics, a performance budget or a test suite. Those are engineering decisions, and a designer who blurs the line there is asking to be trusted on ground they have not earned.

Treat the repository as a spec that happens to compile. If your stack differs, throw the code away and keep the contract: the tokens, the states, and the accessibility behaviour.

❝For most of my career a Figma file was the deliverable. Someone else turned it into software, and the gap between what I drew and what shipped was somebody else's problem to explain.

Working without an engineering team on the other side of a handoff removed that comfort. A file stopped being a deliverable and became an argument I still had to prove. Verdict is what that looks like when nobody is going to catch the parts I got wrong: a contrast gate because I will not remember to check, a lint rule because I will reach for a raw hex at midnight, a matrix of states because I know which ones I skip.

The tooling changed too. Generating six screens in an afternoon is not the interesting part. The interesting part is that when artifacts become nearly free, the only thing left that is scarce is knowing which one to keep.