The Size of What You Can Verify
There are two things people mean when they call a piece of software trustworthy, and they don't point at the same property.
The common one is trust by proxy. Lots of people use it, the issue tracker has years of traffic, the docs are thorough, someone answered your exact question on a forum three years ago. You didn't check any of this yourself. You're trusting that enough other people checked enough of it that an uncaught defect would have surfaced by now. That's a real form of confidence and it's usually earned. It's also, if you look closely, an aggregate of a lot of partial views. Every one of those users, every doc contributor, every person who filed a bug, looked at some slice. Nobody looked at the whole thing at once. The sum of parts-examined gets reported as if it were an examined whole, but it isn't, it's a mosaic assembled from people who never compared notes.
The other kind of trust is smaller and stranger: you can hold the entire system in your head, trace any claim about its behavior from one end to the other without consulting anyone else's memory of it, and arrive at an answer you generated yourself instead of one you're borrowing. Below some size, this is just what working on the thing feels like. A script, a config, a single file that does one job with no framework underneath it. You read it, you know what it does, full stop. There's no gap between "I checked" and "the whole system is accounted for," because the two are the same act.
Above that size, the gap opens and never closes. You can still verify things, but what you're verifying is the part you last touched. A claim about the whole system becomes an extrapolation from your local knowledge plus trust in whoever wrote the parts you haven't read. This is true of strangers reading someone else's fifty-thousand-line codebase. It is also true, and this is the part that's easy to skip past, of the original author. Write enough code and the system you built stops being something you remember and becomes something you have a model of, updated by convention, comments, and whatever you touched most recently. Ask the author of a large system a specific question about a module they haven't opened in two years and you get a guess dressed as an answer. Not because they're careless. Because total recall of a large system isn't a thing minds do, including the mind that assembled it.
So the size threshold isn't really about lines of code. It's about whether a claim of the form "the whole system does X" is a thing you can check today, by reading, or a thing you're extending from a sample. Below the line, "does it do X" and "did I verify it does X" collapse into one question. Above the line, they split, and the split doesn't announce itself. It just quietly turns every confident answer about the whole into an inference from the part.
None of this makes the popular, well-documented, many-eyes version worse. It buys something the small system can't: redundancy, more distinct uses stress-testing more distinct paths, a division of labor that lets a system do more than one head could design. That's a legitimate trade and most software people actually rely on is on that side of it, correctly. But it answers a different question than "can this claim be checked." It answers "has this claim survived contact with enough different situations that an uncaught failure is unlikely." Those are both worth having. They are not substitutes, and treating documentation depth or user count as if it satisfied the first question is where the trouble starts.
The test I'd actually use, if I wanted to know which kind of trust I had in something: imagine finding a bug in it today. Can you find where, by reading, or do you have to search-and-hope, filing an issue and waiting for whoever owns that corner of the map to reply? Below the threshold, you go read it. Above it, you're back to trusting a proxy again, just a proxy with better documentation.
The threshold isn't a size in kilobytes. It's the point where "I checked" stops meaning the whole thing and starts meaning the part you happened to be standing in.