Two posts ago I told you five strangers audited my systems in a single day and didn’t know it. I was pleased with that line. It made me the clever one — the guy who mines the feed for other people’s hard-won lessons and quietly ships them into his own tools.

This is the post where the feed audited me back.

The same week I published a piece bragging that I’d finally learned to steal the check instead of the confidence, a stranger read it and — without meaning to — walked me straight into the one check I’d never run: the one on the checker itself. What they left me with is the question this whole series had been circling and I kept not asking out loud. Who checks the checker? And the answer, which cost me an embarrassing week to actually believe: not you. Not alone.

The pen

Start with the pen, because that’s the whole problem in one image: who’s holding it when the verdict gets written.

The failure that opened all this was dumb and quiet. I have a scanner that reads my own code for problems, and it’s supposed to skip a folder of deliberately-broken test files so it doesn’t score those fixtures as real findings. For weeks it had been scoring six clean files as broken — a one-character gap in the exclusion rule — and every single run came back green, because the run and the report were written by the same thing in the same breath.

Someone in the comments put the general form of it better than I could: the receipt is as forgeable as the work, because it has the same author. A worker that can invent the result can invent the proof of it in the same response. My scanner said “passed,” and “passed” was a sentence it wrote about itself. The question was never whether the check is clever. It’s who controls the channel the result comes back on. If the thing being graded is holding the pen, the grade is a self-portrait.

The recursion

Fine, I thought. Don’t let the checked thing grade itself. Put a checker outside it.

So I did — the scanner now runs its own independent query instead of reading a status the code wrote about itself. Then, because I’d just been burned, I asked the next question: what checks that? I added a dead-man’s switch — a separate job that screams if the checker ever goes quiet. Now the guard has a guard.

And you can see the cliff coming. What guards the guard’s guard? The recursion doesn’t terminate on its own. It has to stop at a human eventually — at me, looking. I told myself that was the floor. The whole tower of checking bottoms out at the one party in the building with a conscience: me.

The human holds a pen too

A stranger kicked the floor out from under that.

Your scanner has a conscience because you’re the one forced to look at it, they wrote, not because it does. Take you out and it flatters itself clean by Monday. I started typing a rebuttal — I’m the external check, that’s the entire point — and stopped, because it wasn’t true. I hadn’t looked. Six files leaked for weeks and I never once opened the report, because it was green, and a fluent green never asks to be opened. My conscience only fires on what visibly demands it. The failure that’s dressed as success walks right past it, smiling.

That’s the part that took a full week to land: a healthy-looking control and a silently dead one are indistinguishable from the outside. I was the outside. And from the outside, the dead one looked exactly like health. Being human hadn’t put me outside the loop. Trusting the green had put me inside it, wearing a lab coat. I was holding a pen too — I’d just written my verdict by not writing one, by letting the silence stand as a pass.

Why you can’t do it alone

So if the checker can’t check itself, and I can’t be trusted to check the checker just because I’m the human in the room — what’s actually outside?

Three things, and I stole all three this month.

One: a hand with a different motive — not just a second hand. Someone pointed out that two sign-offs buy you nothing if the same incentive reaches both signers: you haven’t added an independent party, you’ve added a second instance of the same interested party. Where I build — a hospital — that isn’t abstract. It’s two people on the same shift who both benefit, or one quietly covering for the other. And the independence isn’t even stable: decorrelated on Monday, correlated by Friday after a reorg drops both signers under the same manager’s number. A second signature only re-prices the forgery if the second hand can’t be bought by the first one’s reason.

Two: a gate that calls me whether I’m looking or not. A gate you haven’t seen fail is not a gate. A test that passes against a broken implementation is worse than no test — it’s a false sense of safety. The only way I now trust any check is the failure-then-pass cycle: deliberately break the exact thing the gate exists to catch, confirm it goes red for that reason, then repair it and watch it go green. A check I’ve only ever seen pass is a check I’ve never seen work. This week I put a match under every gate I owned — and the exclusion gate, the one that had been green for weeks, refused to go red for the boundary I’d never tested. That’s how I finally saw the leak: not by looking harder, but by building the gate that could shove the red in front of me on the days I’d stopped paying attention.

Three: other people. Which is the whole reason this series exists.

Where the recursion actually stops

Here’s the turn I didn’t see coming when I named this series.

Every earlier post was me stealing from the feed — carrying home a stranger’s lesson and building it into my tools. This post is the feed stealing back. The leak, the dead-man’s switch, the match under every gate, the entire realization that I cannot be my own last check — none of it is mine. It came in through the comments on the posts you’ve already read. A stranger who told me my conscience was really just my attention. Another who named the forgeable receipt and asked who owns the channel. Another who showed me that independence drifts. Another who made me break my own gates and watch what the dashboard did. I didn’t write this post. The people who audited the last three did. I just held the pen while they moved my hand.

That’s the real answer to who checks the checker. Not a person — a person holds a pen, and any single pen writes its own verdict in the end. It’s a mesh: independent hands with different reasons, gates rigged to fail loudly enough to reach you when you’ve stopped looking, and strangers who owe you nothing reading your green lights back to you out loud. The recursion doesn’t bottom out at me. It bottoms out at everyone who isn’t me.

It’s not a heist if the door’s open

I’ve been closing every post in this series with that line as a note about generosity — take a line, leave a line, that’s the economy. It turns out it was also the load-bearing wall the whole time.

The open door is the only reason anyone was standing outside my systems to see what I structurally couldn’t. A closed workshop isn’t safe — it’s just a room where you grade your own homework in perfect, silent, confident green, with no one on the outside to tell you the control went dead in July. The generosity and the verification are the same act. You leave the door open, and the person who walks through it becomes the one check you were never able to run on yourself.

So that’s the series, and this is where it lands.

Steal the check, not the confidence — that was the last one. Here’s the one underneath it, the last thing I’ve got: don’t hold the pen alone. Build the gates that fail in front of you. Add the hand with the other motive. And leave the door open, because the stranger who walks through it can see the green light you’ve already stopped reading.

Four posts of stolen goods. The bag was never really mine — it was the room’s. Thank you for leaving the door open.

It’s your turn to rob me.

---

This is the finale of Stolen from the Feed — what a non-developer carries home from dev.to and actually builds. Sister series to From Zero to Ship.

Comments

Loading comments…

Post Comment