The Goal With No Grader Doesn't Ship
A team can hold a value for ten years and ship nothing that acts on it. Put that value behind a build step that already fails on something else, and it ships by next release.
This isn't cynicism about values, it's an observation about what actually moves code. A pass/fail test has enforcement built in: something breaks, someone has to fix it before anything else happens. A value has no such mechanism. It competes for attention against every deadline in the schedule and loses, every time, because nothing stops the release if it loses.
Accessibility is the clean example, because the failure mode is so well documented. "We care about users with disabilities" produces a newsletter, maybe a hired consultant, maybe a one-time audit that gets filed and forgotten. What produces actual, maintained screen-reader support is a procurement form a sales contract cannot close without. The compliance report isn't a moral appeal, it's a line item a lawyer on the other side of the deal is going to read. Once the thing a team already treats as binary, pass the review or the deal falls through, has an accessibility checkbox inside it, the accessibility work rides along for free. Nobody needed to get more convinced it mattered. The goal needed to get wired into something that already had teeth.
The same shape sits one level down in ordinary engineering. Test coverage as an aspiration produces a number that drifts downward forever, because nobody loses anything on the day it drops. Test coverage as a CI gate, the merge button disabled below a threshold, produces a number that holds, because now it's inline with the deadline instead of competing against it. Missing translation strings as a someday-task produce an app that's English-only in six markets for years. Missing translation strings as a build failure produce full localization inside a quarter. Same team, same stated priorities before and after. The only thing that changed is which failure mode got hooked to which test.
Underneath this is cost, not willpower. A goal with no grader costs nothing to skip and nothing to half-finish. You can be sixty percent accessible, seventy percent covered, mostly localized, and nothing in the system notices the shortfall, because nothing in the system was built to notice. A binary dependency removes the half-finished state. The build either passes or it doesn't; there's no slot in that outcome for "we mostly got to it."
Worth saying plainly instead of pretending the trick is free: the goal that ships this way only ships exactly as much as the dependency required. A feature built to satisfy one procurement audit covers the workflows that audit happened to check and not necessarily anything past them. A coverage gate rewards hitting the number, and teams will write padding tests to clear it if that's cheaper than writing good ones. The diffuse goal, stated honestly, was always bigger than the narrow test standing in for it. What gets built is the test's shape, not the goal's. That's a real loss. It's still better than the alternative, which is nothing built at all.
So the practical question for anyone who actually wants a diffuse goal to happen isn't how to convince people it matters. It's what already-enforced thing this can attach to, and what narrower, meaner version of the goal that thing is willing to check.
Find the build that already fails on something. Make your thing part of what makes it fail. Everything else was a newsletter.