The first number came back as 442,368. That was just Python, just one switch — verify=False — just the files GitHub's code search could see on a Monday morning. I stared at it for a while, because the story every developer tells about this switch is that it's temporary. Someone hit a certificate error, flipped it off to get past it, and meant to come back. 442,368 files is a lot of people meaning to come back.
So I went looking for the coming back. That is this episode: count the switches, then read what the code around them actually says.
The claim
"Everyone turns TLS verification off sometimes. It's always temporary — a local test, a self-signed cert, a TODO to fix it later."
You have heard some version of this. I have said some version of this. The claim has two parts: the switch is common but excusable, and the excuse is written down next to it. Both parts are checkable, so I checked them.
What I counted
Eight switches, the ones people actually type when they want the certificate check to go away: verify=False (Python's requests and friends), ssl._create_unverified_context, rejectUnauthorized: false (Node), NODE_TLS_REJECT_UNAUTHORIZED=0, CURLOPT_SSL_VERIFYPEER, 0 (PHP and C), --insecure, InsecureSkipVerify: true (Go), and VERIFY_NONE (Ruby). I ran each one through GitHub's code search and wrote down the file count it reported, then split the big ones by language. Then I took the first 20 results for each switch — 200 files — and read the lines around every match, classifying each one: does the comment say it's temporary, does it give a real reason, or does it say nothing at all?
The counts first, because they are the blunt part:
| Switch | Files |
|---|---|
verify=False, all languages | 589,824 |
verify=False, Python | 442,368 |
rejectUnauthorized: false, all | 394,240 |
--insecure | 340,992 |
InsecureSkipVerify: true, all | 126,208 |
ssl._create_unverified_context, all | 72,960 |
CURLOPT_SSL_VERIFYPEER, 0 | 60,160 |
VERIFY_NONE, Ruby | 30,144 |
NODE_TLS_REJECT_UNAUTHORIZED=0 | 22,240 |
Python's verify=False by language, since that is the switch the episode is named after: Python 442,368, Go 2,560, TypeScript 1,484, JavaScript 1,432, PHP 1,060, Java 548, Ruby 179. Those seven add up to 449,631; the other roughly 140,000 sit in languages I didn't split out. And rejectUnauthorized: false splits 234,752 JavaScript to 133,120 TypeScript — the Postgres connection pool in just about every Node backend you have ever seen, usually in a file called db.js. Sixteen of the twenty JavaScript hits I read were a file called db.js. Sixteen.
One honest note on the counting, because I got it wrong before I got it right. My first pass at the fragments looked like the search was matching the two words separately — one file showed ELASTIC_TLS_VERIFY on one line and rejectUnauthorized = false on another, and I nearly wrote up the whole episode on inflated numbers. Then I checked the match positions in the raw results and they pointed at one unbroken string: VERIFY=false inside ELASTIC_TLS_VERIFY=false. The search matches the literal string, quotes or no quotes — I re-ran the counts both ways and got identical totals, and re-ran the first query a few minutes later and got 589,824 again, exactly. So the counts are real. What they are not is pure. The literal string also shows up inside longer names, and the sample is where that gets measured.
What the 200 files actually say
Here is the whole episode in one table. Two hundred files, read one by one:
| What the lines around the switch say | Files |
|---|---|
| Nothing at all | 111 |
| It's in docs or prose, not code using the switch | 60 |
| A real reason is given | 22 |
| It's test, demo, or example code | 4 |
| It's temporary / to fix later | 3 |
Three. Out of two hundred. And if you throw out the 60 docs mentions and look only at the 140 actual code hits, it is still three — 2.1% — against 111 files, 79.3%, that say nothing whatsoever next to the switch.
Here are the three, word for word, because they deserve to be quoted in full and you should judge for yourself how much of a promise each one is:
- "not the best for production use to not verify ssl, but fine for testing" — in a LangChain document-retrieval demo, next to
ssl._create_unverified_context. - "Skip verify by default?" — in a Go HTTP client library, a question, not a plan.
- "Keep getting cert errors?? Had to do this to work around it:" — in a Ruby build script, with two question marks.
One is a shrug, one is a question, one is a workaround note. None of them says "fix later". None of them has a date, a ticket, or a name. The "temporary" story turns out to be something people say about the switch in conversation. In the code, almost nobody says it at all.
The silence has shapes
The 111 silent files are not all the same kind of silent, and the differences matter.
Some of them are worse than silent. One Python helper takes verify=False as its default parameter — every caller gets unverified connections unless they ask otherwise. One Ruby script globally reassigns the constant: OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE, which turns verification off for the whole process, not just one request. Three files have a hardcoded database password sitting a few lines from the switch. One Go file asks its own question and answers it by shipping anyway.
Some of the silence is honest in a different way: the switch is doing exactly what the tool is for. Exploit proofs-of-concept, network scanners, a certificate-inspection tool that has to see the raw certificate — verification would defeat the purpose. Five of the twenty CURLOPT_SSL_VERIFYPEER hits came from a single exploit archive. Those files aren't pretending. They just aren't explaining either.
And then there are the 22 that do explain themselves, and most of them are fine. Self-signed certificates on a local server. A user-facing flag the operator has to choose deliberately — git's own code only turns verification off when its config option says so. The best one I found is in the LastPass command-line client, where the off-switch sits behind a compile flag literally named DO_NOT_ENABLE_ME_MITM_PROXY_FOR_DEBUGGING_ONLY. That is how you write a temporary switch: make it impossible to enable by accident, and name it so nobody can mistake it for normal.
The docs mentions deserve their own paragraph, because they bend two of the counts badly. The top twenty --insecure hits are all documentation — eight of them are translation files for the same download tool, in eight languages, each translating the same help text. The top twenty NODE_TLS_REJECT_UNAUTHORIZED=0 hits are all documentation too, and several of them are warnings against the setting: the MCP inspector docs tell you flat out not to use it, and point at the proper fix instead. So the headline counts include a lot of files that merely talk about the switch. The sample is the correction to the count, not the other way round.
The verdict
| Claim | Measured |
|---|---|
| The switch is rare | 442,368 Python files with verify=False alone; 589,824 across languages |
| It's always temporary | 3 of 200 sampled files say anything like that — and none says "fix later" |
| People explain why they did it | 22 of 200 give a reason; 111 of 140 code hits say nothing |
| The count is all real code | 60 of 200 are docs or prose; the --insecure and NODE_TLS_REJECT_UNAUTHORIZED samples are 20 of 20 docs |
The claim fails on the part that matters. The switch isn't rare, and it isn't temporary — or rather, nobody can show it is temporary, because almost nobody writes that down. What the code actually shows is a switch that gets flipped on, uncommented, and left. The "temporary" part lives in conversation, not in the repository.
The limits, stated plainly
- File counts, not repositories, not people. One file counts once however many times the switch appears; forks count separately, so a switch copied into fifty forks counts fifty times.
- The sample is the search's order, not a random draw. The first twenty results per switch are the best matches, not a lottery. The shares describe those 200 files, and I will not pretend they describe all 589,824.
- The literal string catches lookalikes.
ssl_verify=Falsein Gradio,cert_verify=False,hostkey_verify=False, a JWT library'sverify=False(signature checking, not TLS), a websocket setting with the same field name that checks origins instead of certificates. The sample measures this; the headline count does not separate it. - Docs and tests are inside the counts. The
--insecuretotal is mostly documentation. The Python total includes test files and exploit code. - One morning's snapshot. The counts were taken on 2026-11-16 and they move as code is pushed. Public code only — the default branch, files under 384 KB. Everything behind a private repository is invisible to this measurement.
Run it yourself
Type any of the eight strings into GitHub's code search, with a language filter if you want one — verify=False language:python is the place to start — and read the first page the way I did: not the count, the lines around each match. The full record is in the members' data pack on Patreon, live now, under "LGTM S4 — verify=False in the Wild: Complete Files": every query string, every count with its raw result, and all 200 classified files with the exact comment that put each one in its bucket. If your numbers disagree with mine, that is data too. Tell me.
Next episode, Saturday 19:00: five free tiers, one real job — the same task pushed through five AI tools until each one hits its wall.
If three people in two hundred bothered to say "later", and the rest said nothing at all — how many of those 442,368 files do you think anyone is coming back for?
P.S. Everything I write stays free — that part doesn't change. But if this one was worth something to you, you can buy me a coffee ☕ (one-time or monthly, both work). It covers the API credits and hosting behind these experiments — and honestly, it's also the nudge that gets the next one started on the evenings I'd otherwise skip it. — Salam



