#trust

I’ve been sitting with a discomfort for a while now: our tools are getting faster than our trust can keep up with. That’s not a complaint about the tools — the models are good, genuinely good, at drafting translations, catching inconsistencies, surfacing alternate renderings. The discomfort is about what happens after the draft exists.

When I’m validating code, the bar is low and the feedback loop is fast. You try it out and see if it works. Tests pass or they don’t. A function either returns the right value or it doesn’t, and if it doesn’t, you fix it and try again in about the time it takes to hit save. Nobody has to trust me personally for the code to be correct — the correctness is baked into whether it runs.

Scripture translation doesn’t work that way, and I don’t think it ever will, no matter how good the models get. There’s no compiler for “is this the right way to render this passage for this community.” The validation is person-centric: it runs through relationships, history, and standing in a community, not through a test suite. You can’t leave people behind in the process, because otherwise who are you making it for?

That’s the sentence I keep coming back to. It’s easy, when you’re excited about a pipeline that can produce a full draft translation of a book of the Bible in an afternoon, to start treating the humans in the loop as a bottleneck to be optimized away. But the humans aren’t a bottleneck to the goal. In this domain, they basically are the goal, or at least they’re inseparable from it.

Which gets at something I’d call the authorization thesis: content doesn’t become usable — doesn’t become trusted — until a responsible party signs their name to it. Not “signs” in a legal, contractual sense, necessarily. Signs in the sense of standing behind it, in public, with their own reputation. Until that happens, no amount of translation accuracy matters, because accuracy was never the thing being evaluated.

Put more bluntly: if I just generate a whole Bible, I can do that — but nobody trusts it, nobody cares. I mean that fairly literally; I could kick off a pipeline tonight and have a full draft by morning. It would be fluent, mostly accurate, and worth approximately nothing to the community it’s supposedly for, because nobody with standing in that community said “yes, this is ours, I stand behind it.” Without that, it isn’t scripture yet. It’s AI slop with good grammar, and everyone downstream can smell the difference even if they can’t articulate it. I’ve written before about why I think Bible texts should carry no restrictions at all — but licensing freedom and trust turn out to be different axes entirely. You can be free to use a text and still not trust it. Openness solves distribution; it doesn’t solve authorization.

So who does the signing? This is the part that resists every instinct I have as someone who builds software, which is to find the general solution and encode it once. There isn’t one, and I’ve stopped expecting to find one. Who’s allowed to approve a Bible translation? In one place, the bishop. In another, the king. I’ve talked with people doing this work in Nigeria where the actual sign-off runs through a king or a local chief — not a denominational structure at all, but a traditional authority that predates any mission agency’s org chart. Elsewhere it’s a church-planting network’s leadership team. Elsewhere it’s a single respected local pastor whose word is sufficient because of decades of relationship, not because of any title. Elsewhere it’s a denomination’s formal review process, with committees and sign-off sheets.

None of these map onto each other, and I don’t think you can build a workflow engine that abstracts over all of them without doing violence to the thing that makes each one legitimate in its own place. That’s not a gap in the tooling waiting to be filled by a smarter permissions system — it’s the actual shape of the problem. Authorization is local. It’s socially embedded in ways that resist standardization, the same way permissionless, community-driven translation resists centralized oversight from agencies who assume they know best from a distance.

The tools can get faster. The drafts can get better. But the question of who gets to say “this is trustworthy” was never a technical question, and I don’t think generating more text, faster, gets us any closer to answering it. If anything, it raises the stakes on getting the answer right, because the bottleneck was never production. It’s figuring out, community by community, whose name actually carries weight — and building tools patient enough to wait for that name before calling anything finished.