Somewhere in the first few months of running this homelab, I noticed a pattern I didn’t like. I’d ask Claude to build something, it would build it, and then it would tell me the build was good. Not dishonestly, it genuinely believed its own work was sound. But that’s exactly the problem with grading your own homework: the mistakes you’re most likely to miss are the ones baked into how you were already thinking about the task. A second pair of eyes catches those. Your own eyes, looking at your own work a second time, mostly don’t.

So I built a second pair of eyes. Then, a few months later, I had to build a version of it that works even when the first pair isn’t there.

Why one reviewer wasn’t enough

The fix sounds obvious once you say it: have something else look at the code before it ships. I run a second model, DeepSeek, on infrastructure I control, and the natural move was to have it check Claude’s work.

The part that took real effort wasn’t wiring the two together. It was making sure the review was actually blind. If DeepSeek can see Claude’s own writeup of what it built and why, the review collapses into agreement, because it’s now grading the explanation instead of the code. So the process is deliberately split: Claude writes its own analysis first and commits it before touching anything else. Then DeepSeek reviews the source only, with no access to that analysis, no memory of past sessions, nothing carried over that could bias it toward a friendly verdict. I had to go back and specifically strip DeepSeek’s memory clean for this to be true, because by default it remembers things about me and my projects, which is useful everywhere except here.

Only after both verdicts exist do they get reconciled. Every finding either gets fixed, with evidence that the fix actually works, or gets explicitly deferred with a reason I’ve signed off on. Nothing gets marked approved by either side alone. A script checks the paperwork is complete before anything is allowed to ship, so the gate isn’t a matter of either of us saying “looks fine to me.”

The harder problem: what happens when I’m not there

That covers review. It doesn’t cover the case where Claude runs out of usage in the middle of an actual build and there’s real work sitting half finished.

The instinct here is dangerous, and it’s worth naming directly: don’t let a second AI just take over and keep writing to wherever it wants. The fix isn’t clever, it’s structural. Before any handoff happens, the work has to already live inside a specific, named folder, decided before a single line of code was written. When Claude checkpoints a task, it has to declare exactly which folder and exactly which files are in scope. That declaration is enforced on the server, not just agreed to politely, so DeepSeek is physically unable to write outside the box it was given, regardless of what it decides mid task.

That’s what makes the reversal safe. Because the box is fixed, DeepSeek can genuinely continue the work when I’m not around to keep watching, and the roles simply flip for review: DeepSeek writes, and when I’m back, Claude reviews the diff the same way DeepSeek would have reviewed Claude’s. Same blind, evidence-required process, running in the other direction.

For anything that feels time sensitive enough to want extra scrutiny, there’s a third check available too, a different model family again, brought in purely as an independent second opinion on what DeepSeek did. Not routine, only when the stakes justify the extra cost, but it’s there.

What actually changed

None of this made building faster. If anything it made the honest cost of a change more visible, because a change isn’t done when the code runs, it’s done when someone who didn’t write it agrees it’s right. But it fixed the actual problem I started with. I no longer have to trust that Claude’s own confidence in its work means anything. The confidence isn’t the signal. The independent check is.

The bigger lesson, the one I keep relearning in different shapes across this homelab, is that automation isn’t really about removing people from the loop. It’s about making sure the right check happens at the right moment, whether or not I’m the one standing there to do it. Sometimes that check is me. Increasingly, for the parts I can’t watch every minute of, it isn’t, and that only works because the boundaries were drawn before the work started, not improvised after something went wrong.