Which Pipe to Bang On

Everyone knows the story, or some version of it. A factory’s down, nobody on staff can figure out why, so they call in an old engineer who’s seen the machine before. He walks the floor once, doesn’t touch a wrench, finds the right pipe, and taps it — once — with a hammer. The machine starts. He sends an invoice for ten thousand dollars, itemized: one dollar for the tap, nine thousand nine hundred ninety-nine for knowing where to tap it.

People tell this story to justify what expertise costs. Fine. But it always stops at the invoice, because that’s the convenient place to stop — it lets the story be about knowing and not about doing. Nobody asks what happens if the guy doesn’t have a hammer on him. Or won’t swing it.

I found out what that looks like this week, and it wasn’t a factory. It was my own database.

I run most of the engineering on a personal CRM I built — C2 — off written specs, worked by a small fleet of AI agents. They’re good. Genuinely, uncomfortably good at the kind of work that used to be the whole job: reading a spec, finding every place a tool could fail quietly, and making it fail loudly instead.

Prompt 0007 was a replication brief. C2’s database is local SQLite by design — it works fully offline, no dependency on a network to function — and Litestream mirrors it to a box in DigitalOcean as a durability net, not a sync mechanism. I wrote the spec myself before any of it existed, and buried in task three, I’d already written the whole thesis of this post without meaning to: “Prove the restore. Replicate, destroy the local database, restore from the replica, confirm the data is intact. An untested backup is not a backup — this task is the point of the brief, not step three of five.”

Five tasks. The agents finished three of them in about a day: the runbook, a staleness guard that checks on every command startup and warns if the replica looks newer than the local file, and a hardening sweep across every code path that touches the store — missing config, corrupt database, absent directories, each failing with a message that says what to do next. Nine tests between the two. Genuinely thorough work, the kind that used to take a careful engineer a long, unglamorous afternoon.

Tasks one and three didn’t move. Not because they were hard to write — because they weren’t code problems. They needed real DigitalOcean credentials and a real box running somewhere, and no agent has either of those. For about half a day the status sat at “in-progress,” which was wrong and got corrected to “blocked,” because the two words mean different things and the whole point of the system I’d built was to say which one was true instead of letting a stalled task borrow the good word.

Then it was just me. I got the credentials, stood up the box, pointed Litestream at it. And then came the part nobody could delegate: I destroyed my own live database on purpose — the one with my actual leads and my actual notes in it — and restored it from the replica to see if any of the previous eleven hours had been real.

It was.

Here’s what I keep turning over. The agents could hit every pipe in that system. They found the quiet failure modes, the missing checks, the error messages that used to just crash instead of telling you what to do — and they hit every one of them, methodically, in a day. That’s not a small thing. Most of what “knowing where to tap” used to mean was exactly that kind of exhaustive, patient search, and a lot of it just got cheap.

But there was still exactly one pipe in the whole system that nothing except me could hit, and hitting it wasn’t a tap. It was destruction, on purpose, with something real on the other side of being wrong. The old story ends at the invoice, at the knowing. I don’t think that’s where the value moved. I think it moved one line down — to who’s still willing to swing, and who has to actually live with what happens after.

I wrote the brief. The agents wrote the hardening. Neither of us was ever going to be the one who found out if the backup was real. That was always going to be whoever hit delete.